a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
HiggsThObservables.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2019 HEPfit Collaboration
3 *
4 *
5 * For the licensing terms see doc/COPYING.
6 */
7
9#include "NPbase.h"
10
11muggH::muggH(const StandardModel& SM_i, const double sqrt_s_i)
12: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13{
14 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
15 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
16}
17
19{
20 return myNPbase->muggH(sqrt_s);
21}
22
23muVBF::muVBF(const StandardModel& SM_i, const double sqrt_s_i)
24: ThObservable(SM_i), sqrt_s(sqrt_s_i)
25{
26 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
27 throw std::runtime_error("muVBF called with a class whose parent is not NPbase");
28
29}
30
32{
33 return myNPbase->muVBF(sqrt_s);
34}
35
36muVBFgamma::muVBFgamma(const StandardModel& SM_i, const double sqrt_s_i)
37: ThObservable(SM_i), sqrt_s(sqrt_s_i)
38{
39 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
40 throw std::runtime_error("muVBFgamma called with a class whose parent is not NPbase");
41
42}
43
45{
46 return myNPbase->muVBFgamma(sqrt_s);
47}
48
49mueeWBF::mueeWBF(const StandardModel& SM_i, const double sqrt_s_i)
50: ThObservable(SM_i), sqrt_s(sqrt_s_i)
51{
52 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
53 throw std::runtime_error("mueeWBF called with a class whose parent is not NPbase");
54
55}
56
58{
59 return myNPbase->mueeWBF(sqrt_s);
60}
61
62mueeWBFPol::mueeWBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
63: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
64{
65 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
66 throw std::runtime_error("mueeWBFPol called with a class whose parent is not NPbase");
67}
68
70{
72}
73
74mueeHvv::mueeHvv(const StandardModel& SM_i, const double sqrt_s_i)
75: ThObservable(SM_i), sqrt_s(sqrt_s_i)
76{
77 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
78 throw std::runtime_error("mueeHvv called with a class whose parent is not NPbase");
79}
80
82{
83 return myNPbase->mueeHvv(sqrt_s);
84}
85
86mueeHvvPol::mueeHvvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
87: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
88{
89 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
90 throw std::runtime_error("mueeHvvPol called with a class whose parent is not NPbase");
91}
92
94{
96}
97
98mueeZBF::mueeZBF(const StandardModel& SM_i, const double sqrt_s_i)
99: ThObservable(SM_i), sqrt_s(sqrt_s_i)
100{
101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
102 throw std::runtime_error("mueeZBF called with a class whose parent is not NPbase");
103
104}
105
107{
108 return myNPbase->mueeZBF(sqrt_s);
109}
110
111mueeZBFPol::mueeZBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
112: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
113{
114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
115 throw std::runtime_error("mueeZBFPol called with a class whose parent is not NPbase");
116}
117
119{
121}
122
123muepWBF::muepWBF(const StandardModel& SM_i, const double sqrt_s_i)
124: ThObservable(SM_i), sqrt_s(sqrt_s_i)
125{
126 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
127 throw std::runtime_error("muepWBF called with a class whose parent is not NPbase");
128
129}
130
132{
133 return myNPbase->muepWBF(sqrt_s);
134}
135
136muWH::muWH(const StandardModel& SM_i, const double sqrt_s_i)
137: ThObservable(SM_i), sqrt_s(sqrt_s_i)
138{
139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
140 throw std::runtime_error("muWH called with a class whose parent is not NPbase");
141}
142
144{
145 return myNPbase->muWH(sqrt_s);
146}
147
148muWHpT250::muWHpT250(const StandardModel& SM_i, const double sqrt_s_i)
149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
150{
151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
152 throw std::runtime_error("muWHpT250 called with a class whose parent is not NPbase");
153}
154
156{
157 return myNPbase->muWHpT250(sqrt_s);
158}
159
160muepZBF::muepZBF(const StandardModel& SM_i, const double sqrt_s_i)
161: ThObservable(SM_i), sqrt_s(sqrt_s_i)
162{
163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
164 throw std::runtime_error("muepZBF called with a class whose parent is not NPbase");
165
166}
167
169{
170 return myNPbase->muepZBF(sqrt_s);
171}
172
173muZH::muZH(const StandardModel& SM_i, const double sqrt_s_i)
174: ThObservable(SM_i), sqrt_s(sqrt_s_i)
175{
176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
177 throw std::runtime_error("muZH called with a class whose parent is not NPbase");
178}
179
181{
182 return myNPbase->muZH(sqrt_s);
183}
184
185muZHpT250::muZHpT250(const StandardModel& SM_i, const double sqrt_s_i)
186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
187{
188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
189 throw std::runtime_error("muZHpT250 called with a class whose parent is not NPbase");
190}
191
193{
194 return myNPbase->muZHpT250(sqrt_s);
195}
196
197
198mueeZHGen::mueeZHGen(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
199: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
200{
201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
202 throw std::runtime_error("mueeZHGen called with a class whose parent is not NPbase");
203}
204
206{
208}
209
210
211mueeZH::mueeZH(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
212: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
213{
214 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
215 throw std::runtime_error("mueeZH called with a class whose parent is not NPbase");
216}
217
219{
221}
222
223mueeZllH::mueeZllH(const StandardModel& SM_i, const double sqrt_s_i)
224: ThObservable(SM_i), sqrt_s(sqrt_s_i)
225{
226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
227 throw std::runtime_error("mueeZllH called with a class whose parent is not NPbase");
228}
229
231{
233}
234
235mueeZllHPol::mueeZllHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
236: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
237{
238 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
239 throw std::runtime_error("mueeZllHPol called with a class whose parent is not NPbase");
240}
241
243{
245}
246
247mueeZqqH::mueeZqqH(const StandardModel& SM_i, const double sqrt_s_i)
248: ThObservable(SM_i), sqrt_s(sqrt_s_i)
249{
250 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
251 throw std::runtime_error("mueeZqqH called with a class whose parent is not NPbase");
252}
253
255{
257}
258
259mueeZqqHPol::mueeZqqHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
260: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
261{
262 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
263 throw std::runtime_error("mueeZqqHPol called with a class whose parent is not NPbase");
264}
265
267{
269}
270
271
272aPsk::aPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
273: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
274{
275 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
276 throw std::runtime_error("aPsk called with a class whose parent is not NPbase");
277}
278
280{
282}
283
284
285bPsk::bPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
286: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
287{
288 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
289 throw std::runtime_error("bPsk called with a class whose parent is not NPbase");
290}
291
293{
295}
296
297
298muVH::muVH(const StandardModel& SM_i, const double sqrt_s_i)
299: ThObservable(SM_i), sqrt_s(sqrt_s_i)
300{
301 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
302 throw std::runtime_error("muVH called with a class whose parent is not NPbase");
303}
304
306{
307 return myNPbase->muVH(sqrt_s);
308}
309
310muVHpT250::muVHpT250(const StandardModel& SM_i, const double sqrt_s_i)
311: ThObservable(SM_i), sqrt_s(sqrt_s_i)
312{
313 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
314 throw std::runtime_error("muVHpT250 called with a class whose parent is not NPbase");
315}
316
318{
319 return myNPbase->muVHpT250(sqrt_s);
320}
321
322muVBFpVH::muVBFpVH(const StandardModel& SM_i, const double sqrt_s_i)
323: ThObservable(SM_i), sqrt_s(sqrt_s_i)
324{
325 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
326 throw std::runtime_error("muVBFpVH called with a class whose parent is not NPbase");
327}
328
330{
331 return myNPbase->muVBFpVH(sqrt_s);
332}
333
334muttH::muttH(const StandardModel& SM_i, const double sqrt_s_i)
335: ThObservable(SM_i), sqrt_s(sqrt_s_i)
336{
337 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
338 throw std::runtime_error("muttH called with a class whose parent is not NPbase");
339}
340
342{
343 return myNPbase->muttH(sqrt_s);
344}
345
346mutHq::mutHq(const StandardModel& SM_i, const double sqrt_s_i)
347: ThObservable(SM_i), sqrt_s(sqrt_s_i)
348{
349 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
350 throw std::runtime_error("mutHq called with a class whose parent is not NPbase");
351}
352
354{
355 return myNPbase->mutHq(sqrt_s);
356}
357
358muggHpttH::muggHpttH(const StandardModel& SM_i, const double sqrt_s_i)
359: ThObservable(SM_i), sqrt_s(sqrt_s_i)
360{
361 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
362 throw std::runtime_error("muggHpttH called with a class whose parent is not NPbase");
363}
364
366{
367 return myNPbase->muggHpttH(sqrt_s);
368}
369
370mueettH::mueettH(const StandardModel& SM_i, const double sqrt_s_i)
371: ThObservable(SM_i), sqrt_s(sqrt_s_i)
372{
373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
374 throw std::runtime_error("mueettH called with a class whose parent is not NPbase");
375
376}
377
379{
380 return myNPbase->mueettH(sqrt_s);
381}
382
383mueettHPol::mueettHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
384: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
385{
386 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
387 throw std::runtime_error("mueettHPol called with a class whose parent is not NPbase");
388}
389
391{
393}
394
395mummH::mummH(const StandardModel& SM_i, const double sqrt_s_i)
396: ThObservable(SM_i), sqrt_s(sqrt_s_i)
397{
398 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
399 throw std::runtime_error("mummH called with a class whose parent is not NPbase");
400}
401
403{
404 return myNPbase->mummH(sqrt_s);
405}
406
407mummHNWA::mummHNWA(const StandardModel& SM_i, const double sqrt_s_i)
408: ThObservable(SM_i), sqrt_s(sqrt_s_i)
409{
410 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
411 throw std::runtime_error("mummHNWA called with a class whose parent is not NPbase");
412}
413
415{
416 return myNPbase->mummHNWA(sqrt_s);
417}
418
419// -----------------------------------------------------------------------------
420// Decay widths
421// -----------------------------------------------------------------------------
422
424: ThObservable(SM_i)
425{
426 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
427 throw std::runtime_error("GammaHtoggRatio called with a class whose parent is not NPbase");
428}
429
431{
432 return myNPbase->GammaHggRatio();
433}
434
436: ThObservable(SM_i)
437{
438 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
439 throw std::runtime_error("GammaHtoWWRatio called with a class whose parent is not NPbase");
440}
441
443{
444 return myNPbase->GammaHWWRatio();
445}
446
448: ThObservable(SM_i)
449{
450 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
451 throw std::runtime_error("GammaHtoZZRatio called with a class whose parent is not NPbase");
452}
453
455{
456 return myNPbase->GammaHZZRatio();
457}
458
460{
461 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
462 throw std::runtime_error("GammaHtoZgaRatio called with a class whose parent is not NPbase");
463}
464
466{
467 return myNPbase->GammaHZgaRatio();
468}
469
471{
472 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
473 throw std::runtime_error("GammaHtogagaRatio called with a class whose parent is not NPbase");
474}
475
477{
478 return myNPbase->GammaHgagaRatio();
479}
480
482{
483 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
484 throw std::runtime_error("GammaHtomumuRatio called with a class whose parent is not NPbase");
485}
486
488{
489 return myNPbase->GammaHmumuRatio();
490}
491
493{
494 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
495 throw std::runtime_error("GammaHtotautauRatio called with a class whose parent is not NPbase");
496}
497
499{
500 return myNPbase->GammaHtautauRatio();
501}
502
504{
505 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
506 throw std::runtime_error("GammaHtossRatio called with a class whose parent is not NPbase");
507}
508
510{
511 return myNPbase->GammaHssRatio();
512}
513
515{
516 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
517 throw std::runtime_error("GammaHtoccRatio called with a class whose parent is not NPbase");
518}
519
521{
522 return myNPbase->GammaHccRatio();
523}
524
526{
527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
528 throw std::runtime_error("GammaHtobbRatio called with a class whose parent is not NPbase");
529}
530
532{
533 return myNPbase->GammaHbbRatio();
534}
535
537: ThObservable(SM_i)
538{
539 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
540 throw std::runtime_error("GammaHRatio called with a class whose parent is not NPbase");
541}
542
544{
546}
547
548// -----------------------------------------------------------------------------
549// Branching Ratios
550// -----------------------------------------------------------------------------
551
553{
554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
555 throw std::runtime_error("BrHtoinvRatio called with a class whose parent is not NPbase");
556}
557
559{
560 return myNPbase->BrHtoinvRatio();
561}
562
564: ThObservable(SM_i)
565{
566 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
567 throw std::runtime_error("BrHinvisible called with a class whose parent is not NPbase");
568}
569
571{
572 return myNPbase->Br_H_inv();
573}
574
576: ThObservable(SM_i)
577{
578 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
579 throw std::runtime_error("BrHinvisibleNP called with a class whose parent is not NPbase");
580}
581
583{
584 return myNPbase->Br_H_inv_NP();
585}
586
588: ThObservable(SM_i)
589{
590 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
591 throw std::runtime_error("BrHexotic called with a class whose parent is not NPbase");
592}
593
595{
596 return myNPbase->Br_H_exo();
597}
598
600: ThObservable(SM_i)
601{
602 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
603 throw std::runtime_error("BrHtovisRatio called with a class whose parent is not NPbase");
604}
605
607{
608 return myNPbase->BrHvisRatio();
609}
610
612: ThObservable(SM_i)
613{
614 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
615 throw std::runtime_error("BrHtoggRatio called with a class whose parent is not NPbase");
616}
617
619{
620 return myNPbase->BrHggRatio();
621}
622
624: ThObservable(SM_i)
625{
626 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
627 throw std::runtime_error("BrHtoWWRatio called with a class whose parent is not NPbase");
628}
629
631{
632 return myNPbase->BrHWWRatio();
633}
634
636: ThObservable(SM_i)
637{
638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
639 throw std::runtime_error("BrHtoZZRatio called with a class whose parent is not NPbase");
640}
641
643{
644 return myNPbase->BrHZZRatio();
645}
646
648: ThObservable(SM_i)
649{
650 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
651 throw std::runtime_error("BrHtoVVRatio called with a class whose parent is not NPbase");
652}
653
655{
656 return myNPbase->BrHVVRatio();
657}
658
660{
661 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
662 throw std::runtime_error("BrHtoZgaRatio called with a class whose parent is not NPbase");
663}
664
666{
667 return myNPbase->BrHZgaRatio();
668}
669
671{
672 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
673 throw std::runtime_error("BrHtoZgallRatio called with a class whose parent is not NPbase");
674}
675
677{
678 return myNPbase->BrHZgallRatio();
679}
680
682{
683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
684 throw std::runtime_error("BrHtoZgaeeRatio called with a class whose parent is not NPbase");
685}
686
688{
689 return myNPbase->BrHZgaeeRatio();
690}
691
693{
694 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
695 throw std::runtime_error("BrHtoZgamumuRatio called with a class whose parent is not NPbase");
696}
697
699{
700 return myNPbase->BrHZgamumuRatio();
701}
702
704{
705 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
706 throw std::runtime_error("BrHtogagaRatio called with a class whose parent is not NPbase");
707}
708
710{
711 return myNPbase->BrHgagaRatio();
712}
713
715{
716 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
717 throw std::runtime_error("BrHtomumuRatio called with a class whose parent is not NPbase");
718}
719
721{
722 return myNPbase->BrHmumuRatio();
723}
724
726{
727 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
728 throw std::runtime_error("BrHtotautauRatio called with a class whose parent is not NPbase");
729}
730
732{
733 return myNPbase->BrHtautauRatio();
734}
735
737{
738 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
739 throw std::runtime_error("BrHtoccRatio called with a class whose parent is not NPbase");
740}
741
743{
744 return myNPbase->BrHccRatio();
745}
746
748{
749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
750 throw std::runtime_error("BrHtobbRatio called with a class whose parent is not NPbase");
751}
752
754{
755 return myNPbase->BrHbbRatio();
756}
757
758// -----------------------------------------------------------------------------
759// More 4 fermion decays
760// -----------------------------------------------------------------------------
761
762
764: ThObservable(SM_i)
765{
766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
767 throw std::runtime_error("BrHto2l2vRatio called with a class whose parent is not NPbase");
768}
769
771{
772 return myNPbase->BrH2l2vRatio();
773}
774
775
777: ThObservable(SM_i)
778{
779 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
780 throw std::runtime_error("BrHtoevmuvRatio called with a class whose parent is not NPbase");
781}
782
784{
785 return myNPbase->BrHevmuvRatio();
786}
787
788
790: ThObservable(SM_i)
791{
792 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
793 throw std::runtime_error("BrHto2e2vRatio called with a class whose parent is not NPbase");
794}
795
797{
798 // SM decay widths (from MG simulations)
799 double wH2e2vSM=0.93291e-06, wH2evSM=0.10152e-04;
800
801 // Sum
802 double wH2e2vTSM=wH2e2vSM+wH2evSM;
803
804 return ( (wH2e2vSM*(myNPbase->BrH2e2vRatio()) + wH2evSM*(myNPbase->BrH2evRatio())) / wH2e2vTSM );
805}
806
807
809: ThObservable(SM_i)
810{
811 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
812 throw std::runtime_error("BrHto2mu2vRatio called with a class whose parent is not NPbase");
813}
814
816{
817 // SM decay widths (from MG simulations)
818 double wH2mu2vSM=0.93288e-06, wH2muvSM=0.10163e-04;
819
820 // Sum
821 double wH2mu2vTSM=wH2mu2vSM+wH2muvSM;
822
823 return ( (wH2mu2vSM*(myNPbase->BrH2mu2vRatio()) + wH2muvSM*(myNPbase->BrH2muvRatio())) / wH2mu2vTSM );
824}
825
826
828: ThObservable(SM_i)
829{
830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
831 throw std::runtime_error("BrHto4lRatio called with a class whose parent is not NPbase");
832}
833
835{
836 return myNPbase->BrH4lRatio();
837}
838
839
841: ThObservable(SM_i)
842{
843 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
844 throw std::runtime_error("BrHto4eRatio called with a class whose parent is not NPbase");
845}
846
848{
849 return myNPbase->BrH4eRatio();
850}
851
852
854: ThObservable(SM_i)
855{
856 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
857 throw std::runtime_error("BrHto4muRatio called with a class whose parent is not NPbase");
858}
859
861{
862 return myNPbase->BrH4muRatio();
863}
864
865
867: ThObservable(SM_i)
868{
869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
870 throw std::runtime_error("BrHto2e2muRatio called with a class whose parent is not NPbase");
871}
872
874{
875 return myNPbase->BrH2e2muRatio();
876}
877
878
879
881: ThObservable(SM_i)
882{
883 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
884 throw std::runtime_error("BrHtolljjRatio called with a class whose parent is not NPbase");
885}
886
888{
889 return myNPbase->BrHlljjRatio();
890}
891
892
894: ThObservable(SM_i)
895{
896 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
897 throw std::runtime_error("BrHtolvjjRatio called with a class whose parent is not NPbase");
898}
899
901{
902 return myNPbase->BrHlvjjRatio();
903}
904
905
907: ThObservable(SM_i)
908{
909 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
910 throw std::runtime_error("BrHtolv_lvorjjRatio called with a class whose parent is not NPbase");
911}
912
914{
915 return myNPbase->BrHlv_lvorjjRatio();
916}
917
918
920: ThObservable(SM_i)
921{
922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
923 throw std::runtime_error("BrHtoll_vvorjjRatio called with a class whose parent is not NPbase");
924}
925
927{
928 return myNPbase->BrHll_vvorjjRatio();
929}
930
931// -----------------------------------------------------------------------------
932// Ratios of BR (ratios with SM)
933// -----------------------------------------------------------------------------
934
936{
937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
938 throw std::runtime_error("BrHtogaga_over_mumu_Ratio called with a class whose parent is not NPbase");
939}
940
942{
943 if ((this->getModel()).isModelLinearized()) {
944 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHmumuRatio()));
945 } else {
946 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHmumuRatio());
947 }
948}
949
951{
952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
953 throw std::runtime_error("BrHtoZga_over_mumu_Ratio called with a class whose parent is not NPbase");
954}
955
957{
958 if ((this->getModel()).isModelLinearized()) {
959 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHmumuRatio()));
960 } else {
961 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHmumuRatio());
962 }
963}
964
966{
967 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
968 throw std::runtime_error("BrHtoZmumuga_over_mumu_Ratio called with a class whose parent is not NPbase");
969}
970
972{
973 if ((this->getModel()).isModelLinearized()) {
974 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrHmumuRatio()));
975 } else {
977 }
978}
979
981{
982 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
983 throw std::runtime_error("BrHtoZga_over_4mu_Ratio called with a class whose parent is not NPbase");
984}
985
987{
988 if ((this->getModel()).isModelLinearized()) {
989 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4muRatio()));
990 } else {
991 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4muRatio());
992 }
993}
994
996{
997 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
998 throw std::runtime_error("BrHtoZmumuga_over_4mu_Ratio called with a class whose parent is not NPbase");
999}
1000
1002{
1003 if ((this->getModel()).isModelLinearized()) {
1004 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrH4muRatio()));
1005 } else {
1006 return (myNPbase->BrHZgamumuRatio()) / (myNPbase->BrH4muRatio());
1007 }
1008}
1009
1011{
1012 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1013 throw std::runtime_error("BrHtogaga_over_4l_Ratio called with a class whose parent is not NPbase");
1014}
1015
1017{
1018 if ((this->getModel()).isModelLinearized()) {
1019 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH4lRatio()));
1020 } else {
1021 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH4lRatio());
1022 }
1023}
1024
1026{
1027 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1028 throw std::runtime_error("BrHtobb_over_4l_Ratio called with a class whose parent is not NPbase");
1029}
1030
1032{
1033 if ((this->getModel()).isModelLinearized()) {
1034 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrH4lRatio()));
1035 } else {
1036 return (myNPbase->BrHbbRatio()) / (myNPbase->BrH4lRatio());
1037 }
1038}
1039
1040
1042{
1043 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1044 throw std::runtime_error("BrHto2l2v_over_4l_Ratio called with a class whose parent is not NPbase");
1045}
1046
1048{
1049 if ((this->getModel()).isModelLinearized()) {
1050 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrH4lRatio()));
1051 } else {
1052 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrH4lRatio());
1053 }
1054}
1055
1056
1058{
1059 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1060 throw std::runtime_error("BrHtotautau_over_4l_Ratio called with a class whose parent is not NPbase");
1061}
1062
1064{
1065 if ((this->getModel()).isModelLinearized()) {
1066 return (1.0 + (myNPbase->BrHtautauRatio()) - (myNPbase->BrH4lRatio()));
1067 } else {
1068 return (myNPbase->BrHtautauRatio()) / (myNPbase->BrH4lRatio());
1069 }
1070}
1071
1072
1074{
1075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1076 throw std::runtime_error("BrHtogaga_over_2e2mu_Ratio called with a class whose parent is not NPbase");
1077}
1078
1080{
1081 if ((this->getModel()).isModelLinearized()) {
1082 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH2e2muRatio()));
1083 } else {
1084 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH2e2muRatio());
1085 }
1086}
1087
1089{
1090 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1091 throw std::runtime_error("BrHtoZga_over_4l_Ratio called with a class whose parent is not NPbase");
1092}
1093
1095{
1096 if ((this->getModel()).isModelLinearized()) {
1097 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4lRatio()));
1098 } else {
1099 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4lRatio());
1100 }
1101}
1102
1104{
1105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1106 throw std::runtime_error("BrHtomumu_over_4l_Ratio called with a class whose parent is not NPbase");
1107}
1108
1110{
1111 if ((this->getModel()).isModelLinearized()) {
1112 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4lRatio()));
1113 } else {
1114 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4lRatio());
1115 }
1116}
1117
1119{
1120 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1121 throw std::runtime_error("BrHtomumu_over_4mu_Ratio called with a class whose parent is not NPbase");
1122}
1123
1125{
1126 if ((this->getModel()).isModelLinearized()) {
1127 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4muRatio()));
1128 } else {
1129 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4muRatio());
1130 }
1131}
1132
1134{
1135 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1136 throw std::runtime_error("BrHto4l_over_gaga_Ratio called with a class whose parent is not NPbase");
1137}
1138
1140{
1141 if ((this->getModel()).isModelLinearized()) {
1142 return (1.0 + (myNPbase->BrH4lRatio()) - (myNPbase->BrHgagaRatio()));
1143 } else {
1144 return (myNPbase->BrH4lRatio()) / (myNPbase->BrHgagaRatio());
1145 }
1146}
1147
1149{
1150 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1151 throw std::runtime_error("BrHtoZga_over_gaga_Ratio called with a class whose parent is not NPbase");
1152}
1153
1155{
1156 if ((this->getModel()).isModelLinearized()) {
1157 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHgagaRatio()));
1158 } else {
1159 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHgagaRatio());
1160 }
1161}
1162
1164{
1165 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1166 throw std::runtime_error("BrHtomumu_over_gaga_Ratio called with a class whose parent is not NPbase");
1167}
1168
1170{
1171 if ((this->getModel()).isModelLinearized()) {
1172 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrHgagaRatio()));
1173 } else {
1174 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrHgagaRatio());
1175 }
1176}
1177
1178
1180{
1181 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1182 throw std::runtime_error("BrHto2l2v_over_gaga_Ratio called with a class whose parent is not NPbase");
1183}
1184
1186{
1187 if ((this->getModel()).isModelLinearized()) {
1188 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrHgagaRatio()));
1189 } else {
1190 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrHgagaRatio());
1191 }
1192}
1193
1194
1196{
1197 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1198 throw std::runtime_error("BrHtobb_over_cc_Ratio called with a class whose parent is not NPbase");
1199}
1200
1202{
1203 if ((this->getModel()).isModelLinearized()) {
1204 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrHccRatio()));
1205 } else {
1206 return (myNPbase->BrHbbRatio()) / (myNPbase->BrHccRatio());
1207 }
1208}
1209
1210
1212{
1213 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1214 throw std::runtime_error("BrHtogaga_over_gg_Ratio called with a class whose parent is not NPbase");
1215}
1216
1218{
1219 if ((this->getModel()).isModelLinearized()) {
1220 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHggRatio()));
1221 } else {
1222 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHggRatio());
1223 }
1224}
1225
1226
1228{
1229 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1230 throw std::runtime_error("BrHtogg_over_bb_Ratio called with a class whose parent is not NPbase");
1231}
1232
1234{
1235 if ((this->getModel()).isModelLinearized()) {
1236 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHbbRatio()));
1237 } else {
1238 return (myNPbase->BrHggRatio()) / (myNPbase->BrHbbRatio());
1239 }
1240}
1241
1242
1244{
1245 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1246 throw std::runtime_error("BrHtogg_over_cc_Ratio called with a class whose parent is not NPbase");
1247}
1248
1250{
1251 if ((this->getModel()).isModelLinearized()) {
1252 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHccRatio()));
1253 } else {
1254 return (myNPbase->BrHggRatio()) / (myNPbase->BrHccRatio());
1255 }
1256}
1257
1258
1259// -----------------------------------------------------------------------------
1260// Full signal strengths (prod x decay)
1261// -----------------------------------------------------------------------------
1262
1263muggHgaga::muggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1264: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1265{
1266 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1267 throw std::runtime_error("muggHgaga called with a class whose parent is not NPbase");
1268}
1269
1271{
1272 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1273 //AG: Most general expression including quadratic corrections.
1274 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1275 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1276 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1277 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1278 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1279 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1280
1281 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1282 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1283 double Br1 = dGammaR1-dGammaRTot1;
1284 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1285 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1286 } else {
1287 return myNPbase->muggHgaga(sqrt_s);
1288 }
1289}
1290
1291muggHgagaInt::muggHgagaInt(const StandardModel& SM_i, const double sqrt_s_i)
1292: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1293{
1294 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1295 throw std::runtime_error("muggHgagaInt called with a class whose parent is not NPbase");
1296}
1297
1299{
1301}
1302
1303muVBFHgaga::muVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1304: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1305{
1306 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1307 throw std::runtime_error("muVBFHgaga called with a class whose parent is not NPbase");
1308}
1309
1311{
1312 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1313 //AG: Most general expression including quadratic corrections.
1314 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1315 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1316 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1317 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1318 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1319 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1320
1321 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1322 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1323 double Br1 = dGammaR1-dGammaRTot1;
1324 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1325
1326 double mu;
1327
1328 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1329
1330 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1331
1332 return mu;
1333 } else {
1334 return myNPbase->muVBFHgaga(sqrt_s);
1335 }
1336}
1337
1338muZHgaga::muZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1339: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1340{
1341 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1342 throw std::runtime_error("muZHgaga called with a class whose parent is not NPbase");
1343}
1344
1346{
1347 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1348 //AG: Most general expression including quadratic corrections.
1349 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1350 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1351 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1352 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1353 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1354 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1355
1356 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1357 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1358 double Br1 = dGammaR1-dGammaRTot1;
1359 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1360
1361 double mu;
1362
1363 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1364
1365 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1366
1367 return mu;
1368
1369 } else {
1370 return myNPbase->muZHgaga(sqrt_s);
1371 }
1372}
1373
1374muWHgaga::muWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1375: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1376{
1377 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1378 throw std::runtime_error("muWHgaga called with a class whose parent is not NPbase");
1379}
1380
1382{
1383 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1384 //AG: Most general expression including quadratic corrections.
1385 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1386 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1387 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1388 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1389 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1390 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1391
1392 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1393 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1394 double Br1 = dGammaR1-dGammaRTot1;
1395 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1396
1397 double mu;
1398
1399 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1400
1401 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1402
1403 return mu;
1404
1405 } else {
1406 return myNPbase->muWHgaga(sqrt_s);
1407 }
1408}
1409
1410muVHgaga::muVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1411: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1412{
1413 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1414 throw std::runtime_error("muVHgaga called with a class whose parent is not NPbase");
1415}
1416
1418{
1419 if ((this->getModel()).isModelLinearized()) {
1420 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1421 } else {
1422 return myNPbase->muVHgaga(sqrt_s);
1423 }
1424}
1425
1426muttHgaga::muttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1427: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1428{
1429 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1430 throw std::runtime_error("muttHgaga called with a class whose parent is not NPbase");
1431}
1432
1434{
1435 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1436 //AG: Most general expression including quadratic corrections.
1437 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1438 //return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1439 double muProd1 = myNPbase->delta_muttH_1(sqrt_s);
1440 double muProd2 = myNPbase->delta_muttH_2(sqrt_s);
1441 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1442 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1443
1444 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1445 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1446 double Br1 = dGammaR1-dGammaRTot1;
1447 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1448
1449 double mu;
1450
1451 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1452
1453 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1454
1455 return mu;
1456
1457 } else {
1458 return myNPbase->muttHgaga(sqrt_s);
1459 }
1460}
1461
1462mutHgaga::mutHgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1463: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1464{
1465 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1466 throw std::runtime_error("mutHgaga called with a class whose parent is not NPbase");
1467}
1468
1470{
1471 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1472 //AG: Most general expression including quadratic corrections.
1473 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1474 double muProd1 = myNPbase->delta_mutH_1(sqrt_s);
1475 double muProd2 = myNPbase->delta_mutH_2(sqrt_s);
1476 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1477 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1478
1479 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1480 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1481 double Br1 = dGammaR1-dGammaRTot1;
1482 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1483
1484 double mu;
1485
1486 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1487
1488 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1489
1490 return mu;
1491
1492 } else {
1493 //VM: Just in case someone wants to add directly the production*decay
1494 //(which is the observable we fit at the end)
1495 double NPmutHgaga = myNPbase->mutHgaga(sqrt_s);
1496 if(NPmutHgaga==1.0){
1497 return ((myNPbase->mutH(sqrt_s)) )*(myNPbase->BrHgagaRatio());
1498 } else{
1499 return NPmutHgaga;
1500 }
1501 }
1502}
1503
1504muggHpbbH_Hgaga::muggHpbbH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1505: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1506{
1507 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1508 throw std::runtime_error("muggHpbbH_Hgaga called with a class whose parent is not NPbase");
1509}
1510
1512{
1513 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1514 //AG: Most general expression including quadratic corrections.
1515 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1516 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1517 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1518 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1519 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1520
1521 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1522 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1523 double Br1 = dGammaR1-dGammaRTot1;
1524 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1525
1526 double mu;
1527
1528 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1529
1530 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1531
1532 return mu;
1533
1534 } else {
1535 //VM: Just in case someone wants to add directly the production*decay
1536 //(which is the observable we fit at the end)
1537 //Also, the bbH is missing here, I'll leave it as it was for the
1538 //moment (since bbH is really suppressed).
1539 double NPmuggHpbbH_Hgaga = myNPbase->muggHpbbH_Hgaga(sqrt_s);
1540 if (NPmuggHpbbH_Hgaga == 1.0){
1541 return (myNPbase->muggHgaga(sqrt_s));
1542 } else{
1543 return NPmuggHpbbH_Hgaga;
1544 }
1545 }
1546}
1547
1548muttHptH_Hgaga::muttHptH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1549: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1550{
1551 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1552 throw std::runtime_error("muttHptH_Hgaga called with a class whose parent is not NPbase");
1553}
1554
1556{
1557 //VM:Note that these values are valid for 13 TeV, they are not general
1558 //We should access the SM function that has all the values (for the
1559 //different energies). The values are slightly different, we should
1560 //check this.
1561 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1562 double xsSM_ttH = 0.499873;
1563 double xsSM_tH = 0.0821;
1564 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1565 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1566
1567 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1568 //AG: Most general expression including quadratic corrections.
1569 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1570 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1571 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1572 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1573 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1574
1575 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1576 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1577 double Br1 = dGammaR1-dGammaRTot1;
1578 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1579
1580 double mu;
1581
1582 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1583
1584 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1585
1586 return mu;
1587
1588 } else {
1589 //VM: Just in case someone wants to add directly the production*decay
1590 //(which is the observable we fit at the end)
1591 double NPmuttHptH_Hgaga = myNPbase->muttHptH_Hgaga(sqrt_s);
1592 if(NPmuttHptH_Hgaga==1.0){
1593 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHgagaRatio()) ;
1594 } else {
1595 return NPmuttHptH_Hgaga;
1596 }
1597 }
1598}
1599
1600muggHZga::muggHZga(const StandardModel& SM_i, const double sqrt_s_i)
1601: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1602{
1603 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1604 throw std::runtime_error("muggHZga called with a class whose parent is not NPbase");
1605}
1606
1608{
1609 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1610 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1611 //AG: Most general expression including quadratic corrections.
1612 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1613 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1614 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1615 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1616 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1617
1618 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1619 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1620 double Br1 = dGammaR1-dGammaRTot1;
1621 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1622
1623 double mu;
1624
1625 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1626
1627 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1628
1629 return mu;
1630
1631 } else {
1632 return myNPbase->muggHZga(sqrt_s);
1633 }
1634}
1635
1636muggHZgamumu::muggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
1637: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1638{
1639 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1640 throw std::runtime_error("muggHZgamumu called with a class whose parent is not NPbase");
1641}
1642
1644{
1645 if ((this->getModel()).isModelLinearized()) {
1646 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgamumuRatio()));
1647 } else {
1649 }
1650}
1651
1652muVBFHZga::muVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
1653: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1654{
1655 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1656 throw std::runtime_error("muVBFHZga called with a class whose parent is not NPbase");
1657}
1658
1660{
1661 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1662 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1663 //AG: Most general expression including quadratic corrections.
1664 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1665 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1666 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1667 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1668 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1669
1670 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1671 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1672 double Br1 = dGammaR1-dGammaRTot1;
1673 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1674
1675 double mu;
1676
1677 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1678
1679 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1680
1681 return mu;
1682
1683 } else {
1684 return myNPbase->muVBFHZga(sqrt_s);
1685 }
1686}
1687
1688muZHZga::muZHZga(const StandardModel& SM_i, const double sqrt_s_i)
1689: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1690{
1691 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1692 throw std::runtime_error("muZHZga called with a class whose parent is not NPbase");
1693}
1694
1696{
1697 if ((this->getModel()).isModelLinearized()) {
1698 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1699 } else {
1700 return myNPbase->muZHZga(sqrt_s);
1701 }
1702}
1703
1704muWHZga::muWHZga(const StandardModel& SM_i, const double sqrt_s_i)
1705: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1706{
1707 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1708 throw std::runtime_error("muWHZga called with a class whose parent is not NPbase");
1709}
1710
1712{
1713 if ((this->getModel()).isModelLinearized()) {
1714 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1715 } else {
1716 return myNPbase->muWHZga(sqrt_s);
1717 }
1718}
1719
1720muVHZga::muVHZga(const StandardModel& SM_i, const double sqrt_s_i)
1721: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1722{
1723 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1724 throw std::runtime_error("muVHZga called with a class whose parent is not NPbase");
1725}
1726
1728{
1729 if ((this->getModel()).isModelLinearized()) {
1730 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1731 } else {
1732 return myNPbase->muVHZga(sqrt_s);
1733 }
1734}
1735
1736muttHZga::muttHZga(const StandardModel& SM_i, const double sqrt_s_i)
1737: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1738{
1739 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1740 throw std::runtime_error("muttHZga called with a class whose parent is not NPbase");
1741}
1742
1744{
1745 if ((this->getModel()).isModelLinearized()) {
1746 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1747 } else {
1748 return myNPbase->muttHZga(sqrt_s);
1749 }
1750}
1751
1752
1753
1754
1755
1756muggHpttHptHpbbH_HZga::muggHpttHptHpbbH_HZga(const StandardModel& SM_i, const double sqrt_s_i) //VM:added
1757: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1758{
1759 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1760 throw std::runtime_error("muggHpttHptHpbbH_HZga called with a class whose parent is not NPbase");
1761}
1762
1764{
1765 //VM:Note that these values are valid for 13 TeV, they are not general
1766 //We should access the SM function that has all the values (for the
1767 //different energies). The values are slightly different, we should
1768 //check this. Furthermore, the bbH is not included. In the SM this is
1769 //very suppressed (and it's probably also the case in the SMEFT) but
1770 //in some NP models it may not be the case.Unfortunately, bbH is not
1771 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
1772 //SMEFT and add here the general expression.
1773 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1774 double xsSM_ggHbbH = 44.745;
1775 double xsSM_ttH = 0.4998;
1776 double xsSM_tH = 0.084769;
1777 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
1778 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1779 //double xsSM_tH = myNPbase->computeSigmatH(sqrt_s);
1780 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
1781
1782
1783
1784 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1785 //AG: Most general expression including quadratic corrections.
1786 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1787 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
1788 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
1789 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1790 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1791
1792 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1793 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1794 double Br1 = dGammaR1-dGammaRTot1;
1795 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1796
1797 double mu;
1798
1799 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1800
1801 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1802
1803 return mu;
1804
1805 } else {
1806
1807 //VM: Just in case someone wants to add directly the production*decay
1808 //(which is the observable we fit at the end). Furthermore, the Hbb
1809 //is not added in the original formula, fine for the SM (probably also
1810 //for the SMEFT) but not for all NP models.
1811 double NPmuggHpttHptHpbbH_HZga = myNPbase->muggHpttHptHpbbH_HZga(sqrt_s);
1812 if(NPmuggHpttHptHpbbH_HZga==1.0){
1813 return ( (xsSM_ggHbbH*(myNPbase->muggH(sqrt_s))+xsSM_ttH*(myNPbase->muttH(sqrt_s))+xsSM_tH*(myNPbase->mutH(sqrt_s))) / (xsSM_ggHbbH+xsSM_ttH+xsSM_tH) )*(myNPbase->BrHZgaRatio()) ;
1814 } else {
1815 return NPmuggHpttHptHpbbH_HZga;
1816 }
1817 }
1818}
1819
1820
1821muVBFpVH_HZga::muVBFpVH_HZga(const StandardModel& SM_i, const double sqrt_s_i) //VM:added
1822: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1823{
1824 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1825 throw std::runtime_error("muVBFpVH_HZga called with a class whose parent is not NPbase");
1826}
1827
1829{
1830
1831 //VM:Note that these values are valid for 13 TeV, they are not general
1832 //We should access the SM function that has all the values (for the
1833 //different energies). The values are slightly different, we should
1834 //check this.
1835 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1836 double xsSM_VBF = 3.49948;
1837 double xsSM_WH = 1.21539;
1838 double xsSM_ZH = 0.795910;
1839 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
1840 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
1841 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
1842 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1843 //AG: Most general expression including quadratic corrections.
1844 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1845 double muProd1 = ( xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
1846 double muProd2 = ( xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
1847 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1848 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1849
1850 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1851 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1852 double Br1 = dGammaR1-dGammaRTot1;
1853 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1854
1855 double mu;
1856
1857 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1858
1859 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1860
1861 return mu;
1862
1863 } else {
1864
1865 //VM: Just in case someone wants to add directly the production*decay
1866 //(which is the observable we fit at the end).
1867 double NPmuVBFpVH_HZga = myNPbase->muVBFpVH_HZga(sqrt_s);
1868 if(NPmuVBFpVH_HZga==1.0){
1869 return ( (xsSM_VBF*(myNPbase->muVBF(sqrt_s))+xsSM_WH*(myNPbase->muWH(sqrt_s))+xsSM_ZH*(myNPbase->muZH(sqrt_s))) / (xsSM_VBF+xsSM_WH+xsSM_ZH) )*(myNPbase->BrHZgaRatio()) ;
1870 } else {
1871 return NPmuVBFpVH_HZga;
1872 }
1873 }
1874}
1875
1876
1877
1878
1879
1880
1881muggHZZ::muggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1882: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1883{
1884 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1885 throw std::runtime_error("muggHZZ called with a class whose parent is not NPbase");
1886}
1887
1889{
1890 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1891 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1892 //AG: Most general expression including quadratic corrections.
1893 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1894 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1895 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1896 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1897 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1898
1899 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1900 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1901 double Br1 = dGammaR1-dGammaRTot1;
1902 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1903
1904 double mu;
1905
1906 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1907
1908 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1909
1910 return mu;
1911
1912 } else {
1913 return myNPbase->muggHZZ(sqrt_s);
1914 }
1915}
1916
1917muVBFHZZ::muVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1918: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1919{
1920 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1921 throw std::runtime_error("muVBFHZZ called with a class whose parent is not NPbase");
1922}
1923
1925{
1926 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1927 //AG: Most general expression including quadratic corrections.
1928 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1929 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZZRatio()));
1930 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1931 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1932 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1933 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1934
1935 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1936 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1937 double Br1 = dGammaR1-dGammaRTot1;
1938 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1939
1940 double mu;
1941
1942 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1943
1944 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1945
1946 return mu;
1947
1948 } else {
1949 return myNPbase->muVBFHZZ(sqrt_s);
1950 }
1951}
1952
1953muZHZZ::muZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1954: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1955{
1956 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1957 throw std::runtime_error("muZHZZ called with a class whose parent is not NPbase");
1958}
1959
1961{
1962 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1963 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1964 //AG: Most general expression including quadratic corrections.
1965 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1966 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1967 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1968 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1969 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1970
1971 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1972 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1973 double Br1 = dGammaR1-dGammaRTot1;
1974 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1975
1976 double mu;
1977
1978 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1979
1980 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1981
1982 return mu;
1983
1984 } else {
1985 return myNPbase->muZHZZ(sqrt_s);
1986 }
1987}
1988
1989muWHZZ::muWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1990: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1991{
1992 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1993 throw std::runtime_error("muWHZZ called with a class whose parent is not NPbase");
1994}
1995
1997{
1998 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1999 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZZRatio()));
2000 //AG: Most general expression including quadratic corrections.
2001 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2002 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2003 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2004 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
2005 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
2006
2007 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2008 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2009 double Br1 = dGammaR1-dGammaRTot1;
2010 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2011
2012 double mu;
2013
2014 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2015
2016 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2017
2018 return mu;
2019
2020 } else {
2021 return myNPbase->muWHZZ(sqrt_s);
2022 }
2023}
2024
2025muVHZZ::muVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
2026: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2027{
2028 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2029 throw std::runtime_error("muVHZZ called with a class whose parent is not NPbase");
2030}
2031
2033{
2034 //VM:Note that these values are valid for 13 TeV, they are not general
2035 //We should access the SM function that has all the values (for the
2036 //different energies). The values are slightly different, we should
2037 //check this.
2038 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2039 double xsSM_WH = 1.21539;
2040 double xsSM_ZH = 0.795910;
2041 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2042 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2043 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2044 //AG: Most general expression including quadratic corrections.
2045 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2046 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZZRatio()));
2047 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2048 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2049 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
2050 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
2051
2052 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2053 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2054 double Br1 = dGammaR1-dGammaRTot1;
2055 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2056
2057 double mu;
2058
2059 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2060
2061 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2062
2063 return mu;
2064
2065 } else {
2066 //return myNPbase->muVHZZ(sqrt_s);
2067 //VM: Just in case someone wants to add directly the production*decay
2068 //(which is the observable we fit at the end)
2069 double NPmuVHZZ = myNPbase->muVHZZ(sqrt_s);
2070 if(NPmuVHZZ==1.0){
2071 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHZZRatio());
2072 } else {
2073 return NPmuVHZZ;
2074 }
2075 }
2076}
2077
2078muttHZZ::muttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
2079: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2080{
2081 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2082 throw std::runtime_error("muttHZZ called with a class whose parent is not NPbase");
2083}
2084
2086{
2087 if ((this->getModel()).isModelLinearized()) {
2088 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZZRatio()));
2089 } else {
2090 return myNPbase->muttHZZ(sqrt_s);
2091 }
2092}
2093
2094muttHptH_HZZ::muttHptH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2095: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2096{
2097 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2098 throw std::runtime_error("muttHptH_HZZ called with a class whose parent is not NPbase");
2099}
2100
2102{
2103 //VM:Note that these values are valid for 13 TeV, they are not general
2104 //We should access the SM function that has all the values (for the
2105 //different energies). The values are slightly different, we should
2106 //check this.
2107 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2108 double xsSM_ttH = 0.499873;
2109 double xsSM_tH = 0.0821;
2110 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2111 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2112 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2113 //AG: Most general expression including quadratic corrections.
2114 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2115 //return ( 1.0 + muProd1 + (myNPbase->BrHZZRatio()-1.) );
2116 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2117 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2118 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
2119 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
2120
2121 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2122 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2123 double Br1 = dGammaR1-dGammaRTot1;
2124 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2125
2126 double mu;
2127
2128 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2129
2130 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2131
2132 return mu;
2133
2134 } else {
2135
2136 //VM: Just in case someone wants to add directly the production*decay
2137 //(which is the observable we fit at the end)
2138 double NPmuttHptH_HZZ = myNPbase->muttHptH_HZZ(sqrt_s);
2139 if(NPmuttHptH_HZZ==1.0){
2140 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHZZRatio()) ;
2141 } else {
2142 return NPmuttHptH_HZZ;
2143 }
2144 }
2145}
2146
2147muttHptH_Hmumu::muttHptH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
2148: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2149{
2150 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2151 throw std::runtime_error("muttHptH_Hmumu called with a class whose parent is not NPbase");
2152}
2153
2155{
2156 //VM:Note that these values are valid for 13 TeV, they are not general
2157 //We should access the SM function that has all the values (for the
2158 //different energies). The values are slightly different, we should
2159 //check this.
2160 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2161 double xsSM_ttH = 0.499873;
2162 double xsSM_tH = 0.0821;
2163 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2164 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2165 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2166 //return ( 1.0
2167 // + ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH)
2168 // + (myNPbase->BrHmumuRatio()-1.));
2169 double muProd1 = ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH);
2170 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2171 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2172 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2173
2174 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2175 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2176 double Br1 = dGammaR1-dGammaRTot1;
2177 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2178
2179 double mu;
2180
2181 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2182
2183 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2184
2185 return mu;
2186
2187 } else {
2188
2189 //VM: Just in case someone wants to add directly the production*decay
2190 //(which is the observable we fit at the end)
2191 double NPmuttHptH_Hmumu = myNPbase->muttHptH_Hmumu(sqrt_s);
2192 if(NPmuttHptH_Hmumu==1.0){
2193 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHmumuRatio());
2194 } else {
2195 return NPmuttHptH_Hmumu;
2196 }
2197 }
2198}
2199
2200muggHpbbH_HZZ::muggHpbbH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2201: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2202{
2203 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2204 throw std::runtime_error("muggHpbbH_HZZ called with a class whose parent is not NPbase");
2205}
2206
2208{
2209 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2210 //AG: Most general expression including quadratic corrections.
2211 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2212 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.));
2213 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2214 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2215 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
2216 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
2217
2218 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2219 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2220 double Br1 = dGammaR1-dGammaRTot1;
2221 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2222
2223 double mu;
2224
2225 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2226
2227 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2228
2229 return mu;
2230
2231 } else {
2232 //VM: Just in case someone wants to add directly the production*decay
2233 //(which is the observable we fit at the end)
2234 //Also, the bbH is missing here, I'll leave it as it was for the
2235 //moment (since bbH is really suppressed in the SM).
2236 double NPmuggHpbbH_HZZ = myNPbase->muggHpbbH_HZZ(sqrt_s);
2237 if (NPmuggHpbbH_HZZ == 1.0){
2238 return (myNPbase->muggHZZ(sqrt_s));
2239 } else{
2240 return NPmuggHpbbH_HZZ;
2241 }
2242 }
2243}
2244
2245muggHZZ4l::muggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2246: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2247{
2248 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2249 throw std::runtime_error("muggHZZ4l called with a class whose parent is not NPbase");
2250}
2251
2253{
2254 if ((this->getModel()).isModelLinearized()) {
2255 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2256 } else {
2257 return myNPbase->muggHZZ4l(sqrt_s);
2258 }
2259}
2260
2261muggHZZ4mu::muggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
2262: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2263{
2264 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2265 throw std::runtime_error("muggHZZ4mu called with a class whose parent is not NPbase");
2266}
2267
2269{
2270 if ((this->getModel()).isModelLinearized()) {
2271 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4muRatio()));
2272 } else {
2273 return (myNPbase->muggH(sqrt_s))*(myNPbase->BrH4muRatio());
2274 }
2275}
2276
2277muVBFHZZ4l::muVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2278: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2279{
2280 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2281 throw std::runtime_error("muVBFHZZ4l called with a class whose parent is not NPbase");
2282}
2283
2285{
2286 if ((this->getModel()).isModelLinearized()) {
2287 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH4lRatio()));
2288 } else {
2289 return myNPbase->muVBFHZZ4l(sqrt_s);
2290 }
2291}
2292
2293muZHZZ4l::muZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2294: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2295{
2296 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2297 throw std::runtime_error("muZHZZ4l called with a class whose parent is not NPbase");
2298}
2299
2301{
2302 if ((this->getModel()).isModelLinearized()) {
2303 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2304 } else {
2305 return myNPbase->muZHZZ4l(sqrt_s);
2306 }
2307}
2308
2309muWHZZ4l::muWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2310: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2311{
2312 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2313 throw std::runtime_error("muWHZZ4l called with a class whose parent is not NPbase");
2314}
2315
2317{
2318 if ((this->getModel()).isModelLinearized()) {
2319 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2320 } else {
2321 return myNPbase->muWHZZ4l(sqrt_s);
2322 }
2323}
2324
2325muVHZZ4l::muVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2326: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2327{
2328 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2329 throw std::runtime_error("muVHZZ4l called with a class whose parent is not NPbase");
2330}
2331
2333{
2334 if ((this->getModel()).isModelLinearized()) {
2335 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2336 } else {
2337 return myNPbase->muVHZZ4l(sqrt_s);
2338 }
2339}
2340
2341muttHZZ4l::muttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2342: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2343{
2344 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2345 throw std::runtime_error("muttHZZ4l called with a class whose parent is not NPbase");
2346}
2347
2349{
2350 if ((this->getModel()).isModelLinearized()) {
2351 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2352 } else {
2353 return myNPbase->muttHZZ4l(sqrt_s);
2354 }
2355}
2356
2357muggHWW::muggHWW(const StandardModel& SM_i, const double sqrt_s_i)
2358: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2359{
2360 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2361 throw std::runtime_error("muggHWW called with a class whose parent is not NPbase");
2362}
2363
2365{
2366 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2367 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2368 //AG: Most general expression including quadratic corrections.
2369 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2370 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2371 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2372 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2373 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2374
2375 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2376 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2377 double Br1 = dGammaR1-dGammaRTot1;
2378 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2379
2380 double mu;
2381
2382 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2383
2384 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2385
2386 return mu;
2387
2388 } else {
2389 return myNPbase->muggHWW(sqrt_s);
2390 }
2391}
2392
2393muVBFHWW::muVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
2394: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2395{
2396 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2397 throw std::runtime_error("muVBFHWW called with a class whose parent is not NPbase");
2398}
2399
2401{
2402 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2403 //AG: Most general expression including quadratic corrections.
2404 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2405 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHWWRatio()));
2406 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2407 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2408 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2409 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2410
2411 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2412 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2413 double Br1 = dGammaR1-dGammaRTot1;
2414 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2415
2416 double mu;
2417
2418 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2419
2420 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2421
2422 return mu;
2423
2424 } else {
2425 return myNPbase->muVBFHWW(sqrt_s);
2426 }
2427}
2428
2429muZHWW::muZHWW(const StandardModel& SM_i, const double sqrt_s_i)
2430: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2431{
2432 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2433 throw std::runtime_error("muZHWW called with a class whose parent is not NPbase");
2434}
2435
2437{
2438 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2439 //AG: Most general expression including quadratic corrections.
2440 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2441 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2442 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2443 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2444 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2445 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2446
2447 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2448 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2449 double Br1 = dGammaR1-dGammaRTot1;
2450 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2451
2452 double mu;
2453
2454 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2455
2456 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2457
2458 return mu;
2459
2460 } else {
2461 return myNPbase->muZHWW(sqrt_s);
2462 }
2463}
2464
2465muWHWW::muWHWW(const StandardModel& SM_i, const double sqrt_s_i)
2466: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2467{
2468 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2469 throw std::runtime_error("muWHWW called with a class whose parent is not NPbase");
2470}
2471
2473{
2474 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2475 //AG: Most general expression including quadratic corrections.
2476 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2477 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2478 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2479 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2480 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2481 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2482
2483 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2484 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2485 double Br1 = dGammaR1-dGammaRTot1;
2486 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2487
2488 double mu;
2489
2490 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2491
2492 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2493
2494 return mu;
2495
2496 } else {
2497 return myNPbase->muWHWW(sqrt_s);
2498 }
2499}
2500
2501muVHWW::muVHWW(const StandardModel& SM_i, const double sqrt_s_i)
2502: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2503{
2504 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2505 throw std::runtime_error("muVHWW called with a class whose parent is not NPbase");
2506}
2507
2509{
2510 if ((this->getModel()).isModelLinearized()) {
2511 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2512 } else {
2513 return myNPbase->muVHWW(sqrt_s);
2514 }
2515}
2516
2517muttHWW::muttHWW(const StandardModel& SM_i, const double sqrt_s_i)
2518: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2519{
2520 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2521 throw std::runtime_error("muttHWW called with a class whose parent is not NPbase");
2522}
2523
2525{
2526 if ((this->getModel()).isModelLinearized()) {
2527 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2528 } else {
2529 return myNPbase->muttHWW(sqrt_s);
2530 }
2531}
2532
2533muttHptH_HWW::muttHptH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2534: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2535{
2536 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2537 throw std::runtime_error("muttHptH_HWW called with a class whose parent is not NPbase");
2538}
2539
2541{
2542
2543 //VM:Note that these values are valid for 13 TeV, they are not general
2544 //We should access the SM function that has all the values (for the
2545 //different energies). The values are slightly different, we should
2546 //check this.
2547 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2548 double xsSM_ttH = 0.499873;
2549 double xsSM_tH = 0.0821;
2550 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2551 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2552 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2553 //AG: Most general expression including quadratic corrections.
2554 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2555 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2556 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2557 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2558 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2559
2560 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2561 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2562 double Br1 = dGammaR1-dGammaRTot1;
2563 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2564
2565 double mu;
2566
2567 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2568
2569 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2570
2571 return mu;
2572
2573 } else {
2574
2575 //VM: Just in case someone wants to add directly the production*decay
2576 //(which is the observable we fit at the end)
2577 double NPmuttHptH_HWW = myNPbase->muttHptH_HWW(sqrt_s);
2578 if(NPmuttHptH_HWW==1.0){
2579 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHWWRatio()) ;
2580 } else {
2581 return NPmuttHptH_HWW;
2582 }
2583 }
2584}
2585
2586muggHpbbH_HWW::muggHpbbH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2587: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2588{
2589 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2590 throw std::runtime_error("muggHpbbH_HWW called with a class whose parent is not NPbase");
2591}
2592
2594{
2595 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2596 //AG: Most general expression including quadratic corrections.
2597 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2598 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.));
2599 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2600 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2601 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2602 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2603
2604 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2605 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2606 double Br1 = dGammaR1-dGammaRTot1;
2607 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2608
2609 double mu;
2610
2611 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2612
2613 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2614
2615 return mu;
2616
2617 } else {
2618
2619 //VM: Just in case someone wants to add directly the production*decay
2620 //(which is the observable we fit at the end)
2621 //Also, the bbH is missing here, I'll leave it as it was for the
2622 //moment (since bbH is really suppressed in the SM).
2623 double NPmuggHpbbH_HWW = myNPbase->muggHpbbH_HWW(sqrt_s);
2624 if (NPmuggHpbbH_HWW == 1.0){
2625 return (myNPbase->muggHWW(sqrt_s));
2626 } else{
2627 return NPmuggHpbbH_HWW;
2628 }
2629 }
2630}
2631
2632muggHWW2l2v::muggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2633: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2634{
2635 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2636 throw std::runtime_error("muggHWW2l2v called with a class whose parent is not NPbase");
2637}
2638
2640{
2641 if ((this->getModel()).isModelLinearized()) {
2642 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2643 } else {
2644 return myNPbase->muggHWW2l2v(sqrt_s);
2645 }
2646}
2647
2648muVBFHWW2l2v::muVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2649: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2650{
2651 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2652 throw std::runtime_error("muVBFHWW2l2v called with a class whose parent is not NPbase");
2653}
2654
2656{
2657 if ((this->getModel()).isModelLinearized()) {
2658 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2659 } else {
2660 return myNPbase->muVBFHWW2l2v(sqrt_s);
2661 }
2662}
2663
2664muZHWW2l2v::muZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2665: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2666{
2667 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2668 throw std::runtime_error("muZHWW2l2v called with a class whose parent is not NPbase");
2669}
2670
2672{
2673 if ((this->getModel()).isModelLinearized()) {
2674 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2675 } else {
2676 return myNPbase->muZHWW2l2v(sqrt_s);
2677 }
2678}
2679
2680muWHWW2l2v::muWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2681: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2682{
2683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2684 throw std::runtime_error("muWHWW2l2v called with a class whose parent is not NPbase");
2685}
2686
2688{
2689 if ((this->getModel()).isModelLinearized()) {
2690 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2691 } else {
2692 return myNPbase->muWHWW2l2v(sqrt_s);
2693 }
2694}
2695
2696muVHWW2l2v::muVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2697: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2698{
2699 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2700 throw std::runtime_error("muVHWW2l2v called with a class whose parent is not NPbase");
2701}
2702
2704{
2705 if ((this->getModel()).isModelLinearized()) {
2706 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2707 } else {
2708 return myNPbase->muVHWW2l2v(sqrt_s);
2709 }
2710}
2711
2712muttHWW2l2v::muttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2713: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2714{
2715 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2716 throw std::runtime_error("muttHWW2l2v called with a class whose parent is not NPbase");
2717}
2718
2720{
2721 if ((this->getModel()).isModelLinearized()) {
2722 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2723 } else {
2724 return myNPbase->muttHWW2l2v(sqrt_s);
2725 }
2726}
2727
2728muttHVV::muttHVV(const StandardModel& SM_i, const double sqrt_s_i)
2729: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2730{
2731 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2732 throw std::runtime_error("muttHVV called with a class whose parent is not NPbase");
2733}
2734
2736{
2737 if ((this->getModel()).isModelLinearized()) {
2738 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHVVRatio()));
2739 } else {
2740 return (myNPbase->muttH(sqrt_s)) * (myNPbase->BrHVVRatio());
2741 }
2742}
2743
2744muggHmumu::muggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2745: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2746{
2747 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2748 throw std::runtime_error("muggHmumu called with a class whose parent is not NPbase");
2749}
2750
2752{
2753 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2754 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2755 //AG: Most general expression including quadratic corrections.
2756 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2757 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2758 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2759 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2760 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2761
2762 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2763 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2764 double Br1 = dGammaR1-dGammaRTot1;
2765 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2766
2767 double mu;
2768
2769 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2770
2771 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2772
2773 return mu;
2774
2775 } else {
2776 return myNPbase->muggHmumu(sqrt_s);
2777 }
2778}
2779
2780muVBFHmumu::muVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2781: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2782{
2783 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2784 throw std::runtime_error("muVBFHmumu called with a class whose parent is not NPbase");
2785}
2786
2788{
2789 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2790 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2791 //AG: Most general expression including quadratic corrections.
2792 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2793 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2794 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2795 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2796 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2797
2798 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2799 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2800 double Br1 = dGammaR1-dGammaRTot1;
2801 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2802
2803 double mu;
2804
2805 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2806
2807 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2808
2809 return mu;
2810
2811 } else {
2812 return myNPbase->muVBFHmumu(sqrt_s);
2813 }
2814}
2815
2816muZHmumu::muZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2817: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2818{
2819 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2820 throw std::runtime_error("muZHmumu called with a class whose parent is not NPbase");
2821}
2822
2824{
2825 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2826 //AG: Most general expression including quadratic corrections.
2827 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2828 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2829 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2830 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2831 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2832
2833 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2834 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2835 double Br1 = dGammaR1-dGammaRTot1;
2836 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2837
2838 double mu;
2839
2840 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2841
2842 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2843
2844 return mu;
2845
2846 } else {
2847 return myNPbase->muZHmumu(sqrt_s);
2848 }
2849}
2850
2851muWHmumu::muWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2852: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2853{
2854 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2855 throw std::runtime_error("muWHmumu called with a class whose parent is not NPbase");
2856}
2857
2859{
2860 if ((this->getModel()).isModelLinearized()) {
2861 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2862 } else {
2863 return myNPbase->muWHmumu(sqrt_s);
2864 }
2865}
2866
2867muVHmumu::muVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2868: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2869{
2870 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2871 throw std::runtime_error("muVHmumu called with a class whose parent is not NPbase");
2872}
2873
2875{
2876
2877 //VM:Note that these values are valid for 13 TeV, they are not general
2878 //We should access the SM function that has all the values (for the
2879 //different energies). The values are slightly different, we should
2880 //check this.
2881 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2882 double xsSM_WH = 1.21539;
2883 double xsSM_ZH = 0.795910;
2884 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2885 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2886 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2887 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2888 //AG: Most general expression including quadratic corrections.
2889 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2890 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2891 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2892 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2893 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2894
2895 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2896 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2897 double Br1 = dGammaR1-dGammaRTot1;
2898 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2899
2900 double mu;
2901
2902 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2903
2904 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2905
2906 return mu;
2907
2908 } else {
2909 //return myNPbase->muVHmumu(sqrt_s);
2910 //VM: Just in case someone wants to add directly the production*decay
2911 //(which is the observable we fit at the end)
2912 double NPmuVHmumu = myNPbase->muVHmumu(sqrt_s);
2913 if(NPmuVHmumu==1.0){
2914 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHmumuRatio());
2915 } else {
2916 return NPmuVHmumu;
2917 }
2918
2919 }
2920}
2921
2922muttHmumu::muttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2923: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2924{
2925 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2926 throw std::runtime_error("muttHmumu called with a class whose parent is not NPbase");
2927}
2928
2930{
2931 if ((this->getModel()).isModelLinearized()) {
2932 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2933 } else {
2934 return myNPbase->muttHmumu(sqrt_s);
2935 }
2936}
2937
2938muggHpttHptHpbbH_Hmumu::muggHpttHptHpbbH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2939: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2940{
2941 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2942 throw std::runtime_error("muggHpttHptHpbbH_Hmumu called with a class whose parent is not NPbase");
2943}
2944
2946{
2947 //VM:Note that these values are valid for 13 TeV, they are not general
2948 //We should access the SM function that has all the values (for the
2949 //different energies). The values are slightly different, we should
2950 //check this. Furthermore, the bbH is not included. In the SM this is
2951 //very suppressed (and it's probably also the case in the SMEFT) but
2952 //in some NP models it may not be the case.Unfortunately, bbH is not
2953 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
2954 //SMEFT and add here the general expression.
2955 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2956 double xsSM_ggHbbH = 44.745;
2957 double xsSM_ttH = 0.4998;
2958 double xsSM_tH = 0.084769;
2959 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
2960 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2961 //double xsSM_tH = myNPbase->computeSigmatH(sqrt_s);
2962 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
2963
2964
2965
2966 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2967 //AG: Most general expression including quadratic corrections.
2968 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2969 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2970 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2971 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2972 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2973
2974 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2975 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2976 double Br1 = dGammaR1-dGammaRTot1;
2977 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2978
2979 double mu;
2980
2981 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2982
2983 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2984
2985 return mu;
2986
2987 } else {
2988
2989 //VM: Just in case someone wants to add directly the production*decay
2990 //(which is the observable we fit at the end). Furthermore, the Hbb
2991 //is not added in the original formula, fine for the SM (probably also
2992 //for the SMEFT) but not for all NP models.
2993 double NPmuggHpttHptHpbbH_Hmumu = myNPbase->muggHpttHptHpbbH_Hmumu(sqrt_s);
2994 if(NPmuggHpttHptHpbbH_Hmumu==1.0){
2995 return ( (xsSM_ggHbbH*(myNPbase->muggH(sqrt_s))+xsSM_ttH*(myNPbase->muttH(sqrt_s))+xsSM_tH*(myNPbase->mutH(sqrt_s))) / (xsSM_ggHbbH+xsSM_ttH+xsSM_tH) )*(myNPbase->BrHmumuRatio()) ;
2996 } else {
2997 return NPmuggHpttHptHpbbH_Hmumu;
2998 }
2999 }
3000}
3001
3002muVBFpVH_Hmumu::muVBFpVH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3003: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3004{
3005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3006 throw std::runtime_error("muVBFpVH_Hmumu called with a class whose parent is not NPbase");
3007}
3008
3010{
3011
3012 //VM:Note that these values are valid for 13 TeV, they are not general
3013 //We should access the SM function that has all the values (for the
3014 //different energies). The values are slightly different, we should
3015 //check this.
3016 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3017 double xsSM_VBF = 3.49948;
3018 double xsSM_WH = 1.21539;
3019 double xsSM_ZH = 0.795910;
3020 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
3021 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
3022 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
3023 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3024 //AG: Most general expression including quadratic corrections.
3025 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3026 double muProd1 = ( xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
3027 double muProd2 = ( xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
3028 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
3029 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
3030
3031 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3032 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3033 double Br1 = dGammaR1-dGammaRTot1;
3034 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3035
3036 double mu;
3037
3038 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3039
3040 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3041
3042 return mu;
3043
3044 } else {
3045
3046 //VM: Just in case someone wants to add directly the production*decay
3047 //(which is the observable we fit at the end).
3048 double NPmuVBFpVH_Hmumu = myNPbase->muVBFpVH_Hmumu(sqrt_s);
3049 if(NPmuVBFpVH_Hmumu==1.0){
3050 return ( (xsSM_VBF*(myNPbase->muVBF(sqrt_s))+xsSM_WH*(myNPbase->muWH(sqrt_s))+xsSM_ZH*(myNPbase->muZH(sqrt_s))) / (xsSM_VBF+xsSM_WH+xsSM_ZH) )*(myNPbase->BrHmumuRatio()) ;
3051 } else {
3052 return NPmuVBFpVH_Hmumu;
3053 }
3054 }
3055}
3056
3057muggHtautau::muggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3058: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3059{
3060 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3061 throw std::runtime_error("muggHtautau called with a class whose parent is not NPbase");
3062}
3063
3065{
3066 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3067 //AG: Most general expression including quadratic corrections.
3068 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3069 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3070 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3071 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3072 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3073 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3074
3075 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3076 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3077 double Br1 = dGammaR1-dGammaRTot1;
3078 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3079
3080 double mu;
3081
3082 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3083
3084 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3085
3086 return mu;
3087
3088 } else {
3089 return myNPbase->muggHtautau(sqrt_s);
3090 }
3091}
3092
3093muVBFHtautau::muVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3094: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3095{
3096 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3097 throw std::runtime_error("muVBFHtautau called with a class whose parent is not NPbase");
3098}
3099
3101{
3102 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3103 //AG: Most general expression including quadratic corrections.
3104 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3105 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3106 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
3107 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
3108 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3109 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3110
3111 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3112 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3113 double Br1 = dGammaR1-dGammaRTot1;
3114 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3115
3116 double mu;
3117
3118 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3119
3120 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3121
3122 return mu;
3123
3124 } else {
3125 return myNPbase->muVBFHtautau(sqrt_s);
3126 }
3127}
3128
3129
3130
3131muVBFpVHtautau::muVBFpVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3132: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3133{
3134 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3135 throw std::runtime_error("muVBFpVHtautau called with a class whose parent is not NPbase");
3136}
3137
3139{
3140 if ((this->getModel()).isModelLinearized()) {
3141 return ( -1.0 + (myNPbase->muVBFpVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3142 } else {
3144 }
3145}
3146
3147
3148muZHtautau::muZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3150{
3151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3152 throw std::runtime_error("muZHtautau called with a class whose parent is not NPbase");
3153}
3154
3155double muZHtautau::computeThValue() //AG:modified
3156{
3157 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3158 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3159 //AG: Most general expression including quadratic corrections.
3160 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3161 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3162 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3163 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3164 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3165 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3166
3167 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3168 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3169 double Br1 = dGammaR1-dGammaRTot1;
3170 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3171
3172 double mu;
3173
3174 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3175
3176 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3177
3178 return mu;
3179
3180 } else {
3181 return myNPbase->muZHtautau(sqrt_s);
3182 }
3183}
3184
3185muWHtautau::muWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3187{
3188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3189 throw std::runtime_error("muWHtautau called with a class whose parent is not NPbase");
3190}
3191
3193{
3194 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3195 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3196 //AG: Most general expression including quadratic corrections.
3197 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3198 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3199 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3200 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3201 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3202
3203 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3204 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3205 double Br1 = dGammaR1-dGammaRTot1;
3206 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3207
3208 /*std::cout << "muProd1="<<muProd1<<std::endl;
3209 std::cout << "muProd2="<<muProd2<<std::endl;
3210 std::cout << "dGammaR1="<<dGammaR1<<std::endl;
3211 std::cout << "dGammaR2="<<dGammaR2<<std::endl;
3212 std::cout << "dGammaRTot1="<<dGammaRTot1<<std::endl;
3213 std::cout << "dGammaRTot2="<<dGammaRTot2<<std::endl;
3214
3215 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;
3216 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;*/
3217
3218 double mu;
3219
3220 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3221
3222 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3223
3224 return mu;
3225
3226 } else {
3227 return myNPbase->muWHtautau(sqrt_s);
3228 }
3229}
3230
3231muVHtautau::muVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3232: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3233{
3234 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3235 throw std::runtime_error("muVHtautau called with a class whose parent is not NPbase");
3236}
3237
3239{
3240 //VM:Note that these values are valid for 13 TeV, they are not general
3241 //We should access the SM function that has all the values (for the
3242 //different energies). The values are slightly different, we should
3243 //check this.
3244 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3245 double xsSM_WH = 1.21539;
3246 double xsSM_ZH = 0.795910;
3247 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
3248 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
3249 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3250 //AG: Most general expression including quadratic corrections.
3251 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3252 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3253 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3254 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3255 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3256 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3257
3258 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3259 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3260 double Br1 = dGammaR1-dGammaRTot1;
3261 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3262
3263 double mu;
3264
3265 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3266
3267 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3268
3269 return mu;
3270
3271 } else {
3272 //return myNPbase->muVHtautau(sqrt_s);
3273
3274 //VM: Just in case someone wants to add directly the production*decay
3275 //(which is the observable we fit at the end)
3276 double NPmuVHtautau = myNPbase->muVHtautau(sqrt_s);
3277 if(NPmuVHtautau==1.0){
3278 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHtautauRatio());
3279 } else {
3280 return NPmuVHtautau;
3281 }
3282 }
3283}
3284
3285muttHtautau::muttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3286: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3287{
3288 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3289 throw std::runtime_error("muttHtautau called with a class whose parent is not NPbase");
3290}
3291
3293{
3294 if ((this->getModel()).isModelLinearized()) {
3295 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3296 } else {
3297 return myNPbase->muttHtautau(sqrt_s);
3298 }
3299}
3300
3301muttHptH_Htautau::muttHptH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3302: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3303{
3304 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3305 throw std::runtime_error("muttHptH_Htautau called with a class whose parent is not NPbase");
3306}
3307
3309{
3310 //VM:Note that these values are valid for 13 TeV, they are not general
3311 //We should access the SM function that has all the values (for the
3312 //different energies). The values are slightly different, we should
3313 //check this.
3314 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3315 double xsSM_ttH = 0.499873;
3316 double xsSM_tH = 0.0821;
3317 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3318 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3319 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3320 //AG: Most general expression including quadratic corrections.
3321 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3322 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3323 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3324 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3325 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3326
3327 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3328 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3329 double Br1 = dGammaR1-dGammaRTot1;
3330 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3331
3332 double mu;
3333
3334 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3335
3336 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3337
3338 return mu;
3339
3340 } else {
3341
3342 //VM: Just in case someone wants to add directly the production*decay
3343 //(which is the observable we fit at the end)
3344 double NPmuttHptH_Htautau = myNPbase->muttHptH_Htautau(sqrt_s);
3345 if(NPmuttHptH_Htautau==1.0){
3346 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHtautauRatio()) ;
3347 } else {
3348 return NPmuttHptH_Htautau;
3349 }
3350
3351 }
3352}
3353
3354muggHpbbH_Htautau::muggHpbbH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3355: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3356{
3357 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3358 throw std::runtime_error("muggHpbbH_Htautau called with a class whose parent is not NPbase");
3359}
3360
3362{
3363 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3364 //AG: Most general expression including quadratic corrections.
3365 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3366 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.));
3367 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3368 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3369 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3370 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3371
3372 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3373 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3374 double Br1 = dGammaR1-dGammaRTot1;
3375 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3376
3377 double mu;
3378
3379 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3380
3381 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3382
3383 return mu;
3384
3385 } else {
3386
3387 //VM: Just in case someone wants to add directly the production*decay
3388 //(which is the observable we fit at the end)
3389 //Also, the bbH is missing here, I'll leave it as it was for the
3390 //moment (since bbH is really suppressed in the SM).
3391 double NPmuggHpbbH_Htautau = myNPbase->muggHpbbH_Htautau(sqrt_s);
3392 if (NPmuggHpbbH_Htautau == 1.0){
3393 return (myNPbase->muggHtautau(sqrt_s));
3394 } else{
3395 return NPmuggHpbbH_Htautau;
3396 }
3397 }
3398}
3399
3400muggHbb::muggHbb(const StandardModel& SM_i, const double sqrt_s_i)
3401: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3402{
3403 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3404 throw std::runtime_error("muggHbb called with a class whose parent is not NPbase");
3405}
3406
3408{
3409 if ((this->getModel()).isModelLinearized()) {
3410 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3411 //AG: Most general expression including quadratic corrections.
3412 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3413 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3414 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3415 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3416 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3417
3418 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3419 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3420 double Br1 = dGammaR1-dGammaRTot1;
3421 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3422
3423 double mu;
3424
3425 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3426
3427 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3428
3429 return mu;
3430
3431 } else {
3432 return myNPbase->muggHbb(sqrt_s);
3433 }
3434}
3435
3436muVBFHbb::muVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
3437: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3438{
3439 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3440 throw std::runtime_error("muVBFHbb called with a class whose parent is not NPbase");
3441}
3442
3444{
3445 if ((this->getModel()).isModelLinearized()) {
3446 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHbbRatio()));
3447 } else {
3448 return myNPbase->muVBFHbb(sqrt_s);
3449 }
3450}
3451
3452muZHbb::muZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3453: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3454{
3455 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3456 throw std::runtime_error("muZHbb called with a class whose parent is not NPbase");
3457}
3458
3460{
3461 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3462 //AG: Most general expression including quadratic corrections.
3463 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3464 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3465 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3466 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3467 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3468 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3469
3470 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3471 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3472 double Br1 = dGammaR1-dGammaRTot1;
3473 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3474
3475 double mu;
3476
3477 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3478
3479 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3480
3481 return mu;
3482
3483 } else {
3484 return myNPbase->muZHbb(sqrt_s);
3485 }
3486}
3487
3488muWHbb::muWHbb(const StandardModel& SM_i, const double sqrt_s_i)
3489: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3490{
3491 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3492 throw std::runtime_error("muWHbb called with a class whose parent is not NPbase");
3493}
3494
3496{
3497 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3498 //AG: Most general expression including quadratic corrections.
3499 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3500 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3501 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3502 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3503 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3504 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3505
3506 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3507 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3508 double Br1 = dGammaR1-dGammaRTot1;
3509 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3510
3511 double mu;
3512
3513 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3514
3515 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3516
3517 return mu;
3518
3519 } else {
3520 return myNPbase->muWHbb(sqrt_s);
3521 }
3522}
3523
3524muVHbb::muVHbb(const StandardModel& SM_i, const double sqrt_s_i)
3525: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3526{
3527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3528 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3529}
3530
3532{
3533 if ((this->getModel()).isModelLinearized()) {
3534 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3535 } else {
3536 return myNPbase->muVHbb(sqrt_s);
3537 }
3538}
3539
3540muttHbb::muttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3541: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3542{
3543 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3544 throw std::runtime_error("muttHbb called with a class whose parent is not NPbase");
3545}
3546
3548{
3549 if ((this->getModel()).isModelLinearized()) {
3550 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3551 } else {
3552 return myNPbase->muttHbb(sqrt_s);
3553 }
3554}
3555
3556muttHptH_Hbb::muttHptH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3557: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3558{
3559 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3560 throw std::runtime_error("muttHptH_Hbb called with a class whose parent is not NPbase");
3561}
3562
3564{
3565 //VM:Note that these values are valid for 13 TeV, they are not general
3566 //We should access the SM function that has all the values (for the
3567 //different energies). The values are slightly different, we should
3568 //check this.
3569 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3570 double xsSM_ttH = 0.499873;
3571 double xsSM_tH = 0.0821;
3572 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3573 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3574 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3575 //AG: Most general expression including quadratic corrections.
3576 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3577 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3578 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3579 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3580 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3581
3582 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3583 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3584 double Br1 = dGammaR1-dGammaRTot1;
3585 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3586
3587 double mu;
3588
3589 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3590
3591 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3592
3593 return mu;
3594
3595 } else {
3596
3597
3598 //VM: Just in case someone wants to add directly the production*decay
3599 //(which is the observable we fit at the end)
3600 double NPmuttHptH_Hbb = myNPbase->muttHptH_Hbb(sqrt_s);
3601 if(NPmuttHptH_Hbb==1.0){
3602 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHbbRatio()) ;
3603 } else {
3604 return NPmuttHptH_Hbb;
3605 }
3606 }
3607}
3608
3609muggHpVBFpbbH_Hbb::muggHpVBFpbbH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3610: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3611{
3612 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3613 throw std::runtime_error("muggHpVBFpbbH_Hbb called with a class whose parent is not NPbase");
3614}
3615
3617{
3618 //VM:Note that these values are valid for 13 TeV, they are not general
3619 //We should access the SM function that has all the values (for the
3620 //different energies). The values are slightly different, we should
3621 //check this. Furthermore, the bbH is not included. In the SM this is
3622 //very suppressed (and it's probably also the case in the SMEFT) but
3623 //in some NP models it may not be the case.Unfortunately, bbH is not
3624 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
3625 //SMEFT and add here the general expression.
3626 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3627 double xsSM_ggHbbH = 44.745;
3628 double xsSM_VBF = 3.49948;
3629 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
3630 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
3631 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
3632 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3633 //AG: Most general expression including quadratic corrections.
3634 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3635 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3636 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3637 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3638 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3639
3640 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3641 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3642 double Br1 = dGammaR1-dGammaRTot1;
3643 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3644
3645 double mu;
3646
3647 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3648
3649 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3650
3651 return mu;
3652
3653 } else {
3654
3655
3656 //VM: Just in case someone wants to add directly the production*decay
3657 //(which is the observable we fit at the end). Furthermore, the Hbb
3658 //is not added in the original formula, fine for the SM (probably also
3659 //for the SMEFT) but not for all NP models.
3660 double NPmuggHpVBFpbbH_Hbb = myNPbase->muggHpVBFpbbH_Hbb(sqrt_s);
3661 if(NPmuggHpVBFpbbH_Hbb==1.0){
3662 return ( xsSM_ggHbbH*(myNPbase->muggH(sqrt_s)) + xsSM_VBF*(myNPbase->muVBF(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF) * (myNPbase->BrHbbRatio()) ;
3663 } else {
3664 return NPmuggHpVBFpbbH_Hbb;
3665 }
3666 }
3667}
3668
3669
3670
3671muVHcc::muVHcc(const StandardModel& SM_i, const double sqrt_s_i)
3672: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3673{
3674 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3675 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3676}
3677
3679{
3680 if ((this->getModel()).isModelLinearized()) {
3681 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHccRatio()));
3682 } else {
3683 return myNPbase->muVHcc(sqrt_s);
3684 }
3685}
3686
3687
3688muVBFBRinv::muVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3689: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3690{
3691 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3692 throw std::runtime_error("muVBFBRinv called with a class whose parent is not NPbase");
3693}
3694
3696{
3697
3698 return (myNPbase->muVBF(sqrt_s))*(myNPbase->Br_H_inv());
3699
3700}
3701
3702muVBFHinv::muVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
3703: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3704{
3705 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3706 throw std::runtime_error("muVBFHinv called with a class whose parent is not NPbase");
3707}
3708
3710{
3711
3712 if ((this->getModel()).isModelLinearized()) {
3713 return ((myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3714 } else {
3715 return (myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtoinvRatio());
3716 }
3717
3718}
3719
3720
3721muVHBRinv::muVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3722: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3723{
3724 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3725 throw std::runtime_error("muVHBRinv called with a class whose parent is not NPbase");
3726}
3727
3729{
3730
3731 return (myNPbase->muVH(sqrt_s))*(myNPbase->Br_H_inv());
3732
3733}
3734
3735muVHinv::muVHinv(const StandardModel& SM_i, const double sqrt_s_i)
3736: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3737{
3738 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3739 throw std::runtime_error("muVHinv called with a class whose parent is not NPbase");
3740}
3741
3743{
3744
3745 if ((this->getModel()).isModelLinearized()) {
3746 return ((myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3747 } else {
3748 return (myNPbase->muVH(sqrt_s))*(myNPbase->BrHtoinvRatio());
3749 }
3750
3751}
3752
3753
3754muppHmumu::muppHmumu(const StandardModel& SM_i, const double sqrt_s_i)
3755: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3756{
3757 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3758 throw std::runtime_error("muppHmumu called with a class whose parent is not NPbase");
3759}
3760
3762{
3763 return myNPbase->muppHmumu(sqrt_s);
3764}
3765
3766muppHZga::muppHZga(const StandardModel& SM_i, const double sqrt_s_i)
3767: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3768{
3769 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3770 throw std::runtime_error("muppHZga called with a class whose parent is not NPbase");
3771}
3772
3774{
3775 return myNPbase->muppHZga(sqrt_s);
3776}
3777
3778muggHH2ga2b::muggHH2ga2b(const StandardModel& SM_i, const double sqrt_s_i)
3779: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3780{
3781 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3782 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
3783}
3784
3786{
3787 if ((this->getModel()).isModelLinearized()) {
3788 return (-2.0 + (myNPbase->muggHH(sqrt_s)) + (myNPbase->BrHgagaRatio()) + (myNPbase->BrHbbRatio()));
3789 } else {
3791 }
3792}
3793
3794muttHZbbboost::muttHZbbboost(const StandardModel& SM_i, const double sqrt_s_i)
3795: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3796{
3797 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3798 throw std::runtime_error("muttHZbbboost called with a class whose parent is not NPbase");
3799}
3800
3802{
3803 return (myNPbase->muttHZbbboost(sqrt_s));
3804}
3805
3806muttHgagaZeeboost::muttHgagaZeeboost(const StandardModel& SM_i, const double sqrt_s_i)
3807: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3808{
3809 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3810 throw std::runtime_error("muttHgagaZeeboost called with a class whose parent is not NPbase");
3811}
3812
3814{
3816}
3817
3818//AG:begin
3819ggHgaga::ggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3820: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3821{
3822 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3823 throw std::runtime_error("ggHgaga called with a class whose parent is not NPbase");
3824}
3826{
3827 double SM_prediction = 0.0439; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3828 if ((this->getModel()).isModelLinearized()) {
3829 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3830 } else {
3831 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHgagaRatio());
3832 }
3833}
3834
3835
3836ggHZZ::ggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3837: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3838{
3839 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3840 throw std::runtime_error("ggHZZ called with a class whose parent is not NPbase");
3841}
3843{
3844 double SM_prediction = 0.5197; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3845 if ((this->getModel()).isModelLinearized()) {
3846 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3847 } else {
3848 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHZZRatio());
3849 }
3850}
3851
3852
3853ggHWW::ggHWW(const StandardModel& SM_i, const double sqrt_s_i)
3854: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3855{
3856 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3857 throw std::runtime_error("ggHWW called with a class whose parent is not NPbase");
3858}
3860{
3861 double SM_prediction = 4.1603; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3862 if ((this->getModel()).isModelLinearized()) {
3863 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3864 } else {
3865 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHWWRatio());
3866 }
3867}
3868
3869
3870ggHtautau::ggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3871: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3872{
3873 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3874 throw std::runtime_error("ggHtautau called with a class whose parent is not NPbase");
3875}
3877{
3878 double SM_prediction = 1.2215; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3879 if ((this->getModel()).isModelLinearized()) {
3880 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3881 } else {
3882 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHtautauRatio());
3883 }
3884}
3885
3886
3887VBFHgaga::VBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3888: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3889{
3890 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3891 throw std::runtime_error("VBFHgaga called with a class whose parent is not NPbase");
3892}
3894{
3895 double SM_prediction = 0.0037; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3896 if ((this->getModel()).isModelLinearized()) {
3897 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3898 } else {
3899 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHgagaRatio());
3900 }
3901}
3902
3903
3904VBFHZZ::VBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3905: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3906{
3907 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3908 throw std::runtime_error("VBFHZZ called with a class whose parent is not NPbase");
3909}
3911{
3912 double SM_prediction = 0.0530; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3913 if ((this->getModel()).isModelLinearized()) {
3914 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3915 } else {
3916 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHZZRatio());
3917 }
3918}
3919
3920
3921VBFHWW::VBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
3922: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3923{
3924 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3925 throw std::runtime_error("VBFHWW called with a class whose parent is not NPbase");
3926}
3928{
3929 double SM_prediction = 0.3494; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3930 if ((this->getModel()).isModelLinearized()) {
3931 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3932 } else {
3933 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHWWRatio());
3934 }
3935}
3936
3937
3938VBFHtautau::VBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3939: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3940{
3941 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3942 throw std::runtime_error("VBFHtautau called with a class whose parent is not NPbase");
3943}
3945{
3946 double SM_prediction = 0.1011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3947 if ((this->getModel()).isModelLinearized()) {
3948 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3949 } else {
3950 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtautauRatio());
3951 }
3952}
3953
3954
3955WHgaga::WHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3956: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3957{
3958 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3959 throw std::runtime_error("WHgaga called with a class whose parent is not NPbase");
3960}
3962{
3963 double SM_prediction = 0.0017; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3964 if ((this->getModel()).isModelLinearized()) {
3965 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3966 } else {
3967 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHgagaRatio());
3968 }
3969}
3970
3971
3972WHWW::WHWW(const StandardModel& SM_i, const double sqrt_s_i)
3973: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3974{
3975 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3976 throw std::runtime_error("WHWW called with a class whose parent is not NPbase");
3977}
3979{
3980 double SM_prediction = 0.1614; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3981 if ((this->getModel()).isModelLinearized()) {
3982 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3983 } else {
3984 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHWWRatio());
3985 }
3986}
3987
3988
3989WHtautau::WHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3990: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3991{
3992 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3993 throw std::runtime_error("WWHtautau called with a class whose parent is not NPbase");
3994}
3996{
3997 double SM_prediction = 0.0462; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3998 if ((this->getModel()).isModelLinearized()) {
3999 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
4000 } else {
4001 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHtautauRatio());
4002 }
4003}
4004
4005
4006WHbb::WHbb(const StandardModel& SM_i, const double sqrt_s_i)
4007: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4008{
4009 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4010 throw std::runtime_error("WHbb called with a class whose parent is not NPbase");
4011}
4013{
4014 double SM_prediction = 0.4090; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4015 if ((this->getModel()).isModelLinearized()) {
4016 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
4017 } else {
4018 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHbbRatio());
4019 }
4020}
4021
4022
4023ZHgaga::ZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
4024: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4025{
4026 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4027 throw std::runtime_error("ZHgaga called with a class whose parent is not NPbase");
4028}
4030{
4031 double SM_prediction = 0.0011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4032 if ((this->getModel()).isModelLinearized()) {
4033 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
4034 } else {
4035 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHgagaRatio());
4036 }
4037}
4038
4039
4040ZHWW::ZHWW(const StandardModel& SM_i, const double sqrt_s_i)
4041: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4042{
4043 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4044 throw std::runtime_error("ZHWW called with a class whose parent is not NPbase");
4045}
4047{
4048 double SM_prediction = 0.0996; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4049 if ((this->getModel()).isModelLinearized()) {
4050 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
4051 } else {
4052 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHWWRatio());
4053 }
4054}
4055
4056
4057ZHtautau::ZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
4058: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4059{
4060 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4061 throw std::runtime_error("ZHtautau called with a class whose parent is not NPbase");
4062}
4064{
4065 double SM_prediction = 0.0304; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4066 if ((this->getModel()).isModelLinearized()) {
4067 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
4068 } else {
4069 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHtautauRatio());
4070 }
4071}
4072
4073
4074ZHbb::ZHbb(const StandardModel& SM_i, const double sqrt_s_i)
4075: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4076{
4077 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4078 throw std::runtime_error("ZHbb called with a class whose parent is not NPbase");
4079}
4081{
4082 double SM_prediction = 0.2410; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4083 if ((this->getModel()).isModelLinearized()) {
4084 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
4085 } else {
4086 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHbbRatio());
4087 }
4088}
4089
4090
4091ttHgaga::ttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
4092: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4093{
4094 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4095 throw std::runtime_error("ttHgaga called with a class whose parent is not NPbase");
4096}
4098{
4099 double SM_prediction = 0.0004; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4100 if ((this->getModel()).isModelLinearized()) {
4101 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
4102 } else {
4103 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHgagaRatio());
4104 }
4105}
4106
4107
4108ttHWW::ttHWW(const StandardModel& SM_i, const double sqrt_s_i)
4109: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4110{
4111 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4112 throw std::runtime_error("ttHWW called with a class whose parent is not NPbase");
4113}
4115{
4116 double SM_prediction = 0.0281; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4117 if ((this->getModel()).isModelLinearized()) {
4118 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
4119 } else {
4120 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHWWRatio());
4121 }
4122}
4123
4124
4125ttHtautau::ttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
4126: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4127{
4128 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4129 throw std::runtime_error("ttHtautau called with a class whose parent is not NPbase");
4130}
4132{
4133 double SM_prediction = 0.0106; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4134 if ((this->getModel()).isModelLinearized()) {
4135 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
4136 } else {
4137 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHtautauRatio());
4138 }
4139}
4140
4141
4142ttHbb::ttHbb(const StandardModel& SM_i, const double sqrt_s_i)
4143: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4144{
4145 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4146 throw std::runtime_error("ttHbb called with a class whose parent is not NPbase");
4147}
4149{
4150 double SM_prediction = 0.0751; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4151 if ((this->getModel()).isModelLinearized()) {
4152 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
4153 } else {
4154 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHbbRatio());
4155 }
4156}
4157
4158//AG:end
4159
4160UpperLimit_ppHZgammaA::UpperLimit_ppHZgammaA(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4161{
4162 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4163 throw std::runtime_error("UpperLimit_ppHZgammaA called with a class whose parent is not NPbase");
4164}
4165
4167{
4169}
4170
4171UpperLimit_ppHZgammaA13::UpperLimit_ppHZgammaA13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4172{
4173 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4174 throw std::runtime_error("UpperLimit_ppHZgammaA13 called with a class whose parent is not NPbase");
4175}
4176
4178{
4180}
4181
4182UpperLimit_ppHZgammaC13::UpperLimit_ppHZgammaC13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4183{
4184 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4185 throw std::runtime_error("UpperLimit_ppHZgammaC13 called with a class whose parent is not NPbase");
4186}
4187
4189{
4191}
4192
4193UpperLimit_ppHZgammaC::UpperLimit_ppHZgammaC(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4194{
4195 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4196 throw std::runtime_error("UpperLimit_ppHZgammaC called with a class whose parent is not NPbase");
4197}
4198
4200{
4202}
4203
4205{
4206 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4207 throw std::runtime_error("cg_plus_ct called with a class whose parent is not NPbase");
4208}
4209
4211{
4212 return myNPbase->cgplusct();
4213}
4214
4216{
4217 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4218 throw std::runtime_error("cga_plus_ct called with a class whose parent is not NPbase");
4219}
4220
4222{
4223 return myNPbase->cgaplusct();
4224}
4225
4227{
4228 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4229 throw std::runtime_error("cg_minus_cga called with a class whose parent is not NPbase");
4230}
4231
4233{
4234 return myNPbase->cgminuscga();
4235}
4236
4238{
4239 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4240 throw std::runtime_error("cV_plus_cb called with a class whose parent is not NPbase");
4241}
4242\
4243
4244
4246{
4247 return myNPbase->cVpluscb();
4248}
4249
4251{
4252 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4253 throw std::runtime_error("cV_plus_ctau called with a class whose parent is not NPbase");
4254}
4255
4257{
4258 return myNPbase->cVplusctau();
4259}
4260
4262{
4263 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4264 throw std::runtime_error("cb_minus_cc called with a class whose parent is not NPbase");
4265}
4266
4268{
4269 return myNPbase->cbminuscc();
4270}
4271
4273{
4274 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4275 throw std::runtime_error("cb_minus_ctau called with a class whose parent is not NPbase");
4276}
4277
4279{
4280 return myNPbase->cbminusctau();
4281}
4282
4284{
4285 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4286 throw std::runtime_error("cc_minus_ctau called with a class whose parent is not NPbase");
4287}
4288
4290{
4291 return myNPbase->ccminusctau();
4292}
4293
4294
4295// Full signal strengths at e+ e- colliders
4296// ----------------------------------------
4297
4298mueeZHbb::mueeZHbb(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4299: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4300{
4301 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4302 throw std::runtime_error("mueeZHbb called with a class whose parent is not NPbase");
4303}
4304
4306{
4307 if ((this->getModel()).isModelLinearized()) {
4309 } else {
4311 }
4312}
4313
4314mueeZHcc::mueeZHcc(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4315: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4316{
4317 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4318 throw std::runtime_error("mueeZHcc called with a class whose parent is not NPbase");
4319}
4320
4322{
4323 if ((this->getModel()).isModelLinearized()) {
4325 } else {
4327 }
4328}
4329
4330mueeZHss::mueeZHss(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4331: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4332{
4333 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4334 throw std::runtime_error("mueeZHss called with a class whose parent is not NPbase");
4335}
4336
4338{
4339 if ((this->getModel()).isModelLinearized()) {
4341 } else {
4343 }
4344}
4345
4346mueeZHgg::mueeZHgg(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4347: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4348{
4349 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4350 throw std::runtime_error("mueeZHgg called with a class whose parent is not NPbase");
4351}
4352
4354{
4355 if ((this->getModel()).isModelLinearized()) {
4357 } else {
4359 }
4360}
4361
4362mueeZHWW::mueeZHWW(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4363: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4364{
4365 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4366 throw std::runtime_error("mueeZHWW called with a class whose parent is not NPbase");
4367}
4368
4370{
4371 if ((this->getModel()).isModelLinearized()) {
4373 } else {
4375 }
4376}
4377
4378mueeZHtautau::mueeZHtautau(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4379: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4380{
4381 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4382 throw std::runtime_error("mueeZHtautau called with a class whose parent is not NPbase");
4383}
4384
4386{
4387 if ((this->getModel()).isModelLinearized()) {
4389 } else {
4391 }
4392}
4393
4394mueeZHZZ::mueeZHZZ(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4395: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4396{
4397 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4398 throw std::runtime_error("mueeZHZZ called with a class whose parent is not NPbase");
4399}
4400
4402{
4403 if ((this->getModel()).isModelLinearized()) {
4405 } else {
4407 }
4408}
4409
4410mueeZHZga::mueeZHZga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4411: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4412{
4413 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4414 throw std::runtime_error("mueeZHZga called with a class whose parent is not NPbase");
4415}
4416
4418{
4419 if ((this->getModel()).isModelLinearized()) {
4421 } else {
4423 }
4424}
4425
4426mueeZHgaga::mueeZHgaga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4427: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4428{
4429 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4430 throw std::runtime_error("mueeZHgaga called with a class whose parent is not NPbase");
4431}
4432
4434{
4435 if ((this->getModel()).isModelLinearized()) {
4437 } else {
4439 }
4440}
4441
4442mueeZHmumu::mueeZHmumu(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4443: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4444{
4445 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4446 throw std::runtime_error("mueeZHmumu called with a class whose parent is not NPbase");
4447}
4448
4450{
4451 if ((this->getModel()).isModelLinearized()) {
4453 } else {
4455 }
4456}
4457
4458mueeZHBRinv::mueeZHBRinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4459: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4460{
4461 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4462 throw std::runtime_error("mueeZHBRinv called with a class whose parent is not NPbase");
4463}
4464
4466{
4467
4469
4470}
4471
4472mueeZHinv::mueeZHinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4473: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4474{
4475 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4476 throw std::runtime_error("mueeZHinv called with a class whose parent is not NPbase");
4477}
4478
4480{
4481
4482 if ((this->getModel()).isModelLinearized()) {
4484 } else {
4486 }
4487
4488}
4489
4490mueeWBFbb::mueeWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4491: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4492{
4493 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4494 throw std::runtime_error("mueeWBFbb called with a class whose parent is not NPbase");
4495
4496}
4497
4499{
4500 if ((this->getModel()).isModelLinearized()) {
4502 } else {
4503 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHbbRatio());
4504 }
4505}
4506
4507mueeWBFbbPol::mueeWBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4508: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4509{
4510 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4511 throw std::runtime_error("mueeWBFbbPol called with a class whose parent is not NPbase");
4512
4513}
4514
4516{
4517 if ((this->getModel()).isModelLinearized()) {
4519 } else {
4521 }
4522}
4523
4524mueeWBFcc::mueeWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
4525: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4526{
4527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4528 throw std::runtime_error("mueeWBFcc called with a class whose parent is not NPbase");
4529
4530}
4531
4533{
4534 if ((this->getModel()).isModelLinearized()) {
4536 } else {
4537 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHccRatio());
4538 }
4539}
4540
4541mueeWBFgg::mueeWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
4542: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4543{
4544 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4545 throw std::runtime_error("mueeWBFgg called with a class whose parent is not NPbase");
4546
4547}
4548
4550{
4551 if ((this->getModel()).isModelLinearized()) {
4553 } else {
4554 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHggRatio());
4555 }
4556}
4557
4558mueeWBFWW::mueeWBFWW(const StandardModel& SM_i, const double sqrt_s_i)
4559: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4560{
4561 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4562 throw std::runtime_error("mueeWBFWW called with a class whose parent is not NPbase");
4563
4564}
4565
4567{
4568 if ((this->getModel()).isModelLinearized()) {
4570 } else {
4571 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHWWRatio());
4572 }
4573}
4574
4575mueeWBFtautau::mueeWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
4576: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4577{
4578 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4579 throw std::runtime_error("mueeWBFtautau called with a class whose parent is not NPbase");
4580
4581}
4582
4584{
4585 if ((this->getModel()).isModelLinearized()) {
4587 } else {
4589 }
4590}
4591
4592mueeWBFZZ::mueeWBFZZ(const StandardModel& SM_i, const double sqrt_s_i)
4593: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4594{
4595 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4596 throw std::runtime_error("mueeWBFZZ called with a class whose parent is not NPbase");
4597
4598}
4599
4601{
4602 if ((this->getModel()).isModelLinearized()) {
4604 } else {
4605 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZZRatio());
4606 }
4607}
4608
4609mueeWBFZga::mueeWBFZga(const StandardModel& SM_i, const double sqrt_s_i)
4610: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4611{
4612 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4613 throw std::runtime_error("mueeWBFZga called with a class whose parent is not NPbase");
4614
4615}
4616
4618{
4619 if ((this->getModel()).isModelLinearized()) {
4621 } else {
4622 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZgaRatio());
4623 }
4624}
4625
4626mueeWBFgaga::mueeWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
4627: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4628{
4629 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4630 throw std::runtime_error("mueeWBFgaga called with a class whose parent is not NPbase");
4631
4632}
4633
4635{
4636 if ((this->getModel()).isModelLinearized()) {
4638 } else {
4640 }
4641}
4642
4643mueeWBFmumu::mueeWBFmumu(const StandardModel& SM_i, const double sqrt_s_i)
4644: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4645{
4646 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4647 throw std::runtime_error("mueeWBFmumu called with a class whose parent is not NPbase");
4648
4649}
4650
4652{
4653 if ((this->getModel()).isModelLinearized()) {
4655 } else {
4657 }
4658}
4659
4660mueeHvvbb::mueeHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
4661: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4662{
4663 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4664 throw std::runtime_error("mueeHvvbb called with a class whose parent is not NPbase");
4665
4666}
4667
4669{
4670 if ((this->getModel()).isModelLinearized()) {
4672 } else {
4673 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHbbRatio());
4674 }
4675}
4676
4677mueeHvvbbPol::mueeHvvbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4678: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4679{
4680 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4681 throw std::runtime_error("mueeHvvbbPol called with a class whose parent is not NPbase");
4682
4683}
4684
4686{
4687 if ((this->getModel()).isModelLinearized()) {
4689 } else {
4691 }
4692}
4693
4694mueeHvvcc::mueeHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
4695: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4696{
4697 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4698 throw std::runtime_error("mueeHvvcc called with a class whose parent is not NPbase");
4699
4700}
4701
4703{
4704 if ((this->getModel()).isModelLinearized()) {
4706 } else {
4707 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHccRatio());
4708 }
4709}
4710
4711mueeHvvccPol::mueeHvvccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4712: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4713{
4714 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4715 throw std::runtime_error("mueeHvvccPol called with a class whose parent is not NPbase");
4716
4717}
4718
4720{
4721 if ((this->getModel()).isModelLinearized()) {
4723 } else {
4725 }
4726}
4727
4728
4729mueeHvvss::mueeHvvss(const StandardModel& SM_i, const double sqrt_s_i)
4730: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4731{
4732 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4733 throw std::runtime_error("mueeHvvss called with a class whose parent is not NPbase");
4734
4735}
4736
4738{
4739 if ((this->getModel()).isModelLinearized()) {
4741 } else {
4742 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHssRatio());
4743 }
4744}
4745
4746mueeHvvssPol::mueeHvvssPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4747: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4748{
4749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4750 throw std::runtime_error("mueeHvvssPol called with a class whose parent is not NPbase");
4751
4752}
4753
4755{
4756 if ((this->getModel()).isModelLinearized()) {
4758 } else {
4760 }
4761}
4762
4763
4764mueeHvvgg::mueeHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
4765: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4766{
4767 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4768 throw std::runtime_error("mueeHvvgg called with a class whose parent is not NPbase");
4769
4770}
4771
4773{
4774 if ((this->getModel()).isModelLinearized()) {
4776 } else {
4777 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHggRatio());
4778 }
4779}
4780
4781mueeHvvggPol::mueeHvvggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4782: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4783{
4784 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4785 throw std::runtime_error("mueeHvvggPol called with a class whose parent is not NPbase");
4786
4787}
4788
4790{
4791 if ((this->getModel()).isModelLinearized()) {
4793 } else {
4795 }
4796}
4797
4798mueeHvvWW::mueeHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
4799: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4800{
4801 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4802 throw std::runtime_error("mueeHvvWW called with a class whose parent is not NPbase");
4803
4804}
4805
4807{
4808 if ((this->getModel()).isModelLinearized()) {
4810 } else {
4811 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHWWRatio());
4812 }
4813}
4814
4815mueeHvvWWPol::mueeHvvWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4816: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4817{
4818 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4819 throw std::runtime_error("mueeHvvWWPol called with a class whose parent is not NPbase");
4820
4821}
4822
4824{
4825 if ((this->getModel()).isModelLinearized()) {
4827 } else {
4829 }
4830}
4831
4832mueeHvvtautau::mueeHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
4833: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4834{
4835 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4836 throw std::runtime_error("mueeHvvtautau called with a class whose parent is not NPbase");
4837
4838}
4839
4841{
4842 if ((this->getModel()).isModelLinearized()) {
4844 } else {
4846 }
4847}
4848
4849mueeHvvtautauPol::mueeHvvtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4850: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4851{
4852 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4853 throw std::runtime_error("mueeHvvtautauPol called with a class whose parent is not NPbase");
4854
4855}
4856
4858{
4859 if ((this->getModel()).isModelLinearized()) {
4861 } else {
4863 }
4864}
4865
4866mueeHvvZZ::mueeHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
4867: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4868{
4869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4870 throw std::runtime_error("mueeHvvZZ called with a class whose parent is not NPbase");
4871
4872}
4873
4875{
4876 if ((this->getModel()).isModelLinearized()) {
4878 } else {
4879 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZZRatio());
4880 }
4881}
4882
4883mueeHvvZZPol::mueeHvvZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4884: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4885{
4886 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4887 throw std::runtime_error("mueeHvvZZPol called with a class whose parent is not NPbase");
4888
4889}
4890
4892{
4893 if ((this->getModel()).isModelLinearized()) {
4895 } else {
4897 }
4898}
4899
4900mueeHvvZga::mueeHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
4901: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4902{
4903 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4904 throw std::runtime_error("mueeHvvZga called with a class whose parent is not NPbase");
4905
4906}
4907
4909{
4910 if ((this->getModel()).isModelLinearized()) {
4912 } else {
4913 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
4914 }
4915}
4916
4917mueeHvvZgaPol::mueeHvvZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4918: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4919{
4920 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4921 throw std::runtime_error("mueeHvvZgaPol called with a class whose parent is not NPbase");
4922
4923}
4924
4926{
4927 if ((this->getModel()).isModelLinearized()) {
4929 } else {
4931 }
4932}
4933
4934mueeHvvgaga::mueeHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
4935: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4936{
4937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4938 throw std::runtime_error("mueeHvvgaga called with a class whose parent is not NPbase");
4939
4940}
4941
4943{
4944 if ((this->getModel()).isModelLinearized()) {
4946 } else {
4948 }
4949}
4950
4951mueeHvvgagaPol::mueeHvvgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4952: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4953{
4954 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4955 throw std::runtime_error("mueeHvvgagaPol called with a class whose parent is not NPbase");
4956
4957}
4958
4960{
4961 if ((this->getModel()).isModelLinearized()) {
4963 } else {
4965 }
4966}
4967
4968mueeHvvmumu::mueeHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
4969: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4970{
4971 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4972 throw std::runtime_error("mueeHvvmumu called with a class whose parent is not NPbase");
4973
4974}
4975
4977{
4978 if ((this->getModel()).isModelLinearized()) {
4980 } else {
4982 }
4983}
4984
4985mueeHvvmumuPol::mueeHvvmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4986: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4987{
4988 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4989 throw std::runtime_error("mueeHvvmumuPol called with a class whose parent is not NPbase");
4990
4991}
4992
4994{
4995 if ((this->getModel()).isModelLinearized()) {
4997 } else {
4999 }
5000}
5001
5002mueeZBFbb::mueeZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5003: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5004{
5005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5006 throw std::runtime_error("mueeZBFbb called with a class whose parent is not NPbase");
5007}
5008
5010{
5011 if ((this->getModel()).isModelLinearized()) {
5013 } else {
5014 return (myNPbase->mueeZBF(sqrt_s))*(myNPbase->BrHbbRatio());
5015 }
5016}
5017
5018mueeZBFbbPol::mueeZBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
5019: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
5020{
5021 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5022 throw std::runtime_error("mueeZBFbbPol called with a class whose parent is not NPbase");
5023}
5024
5026{
5027 if ((this->getModel()).isModelLinearized()) {
5029 } else {
5031 }
5032}
5033
5034mueettHbb::mueettHbb(const StandardModel& SM_i, const double sqrt_s_i)
5035: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5036{
5037 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5038 throw std::runtime_error("mueettHbb called with a class whose parent is not NPbase");
5039}
5040
5042{
5043 if ((this->getModel()).isModelLinearized()) {
5045 } else {
5046 return (myNPbase->mueettH(sqrt_s))*(myNPbase->BrHbbRatio());
5047 }
5048}
5049
5050mueettHbbPol::mueettHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
5051: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
5052{
5053 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5054 throw std::runtime_error("mueettHbbPol called with a class whose parent is not NPbase");
5055}
5056
5058{
5059 if ((this->getModel()).isModelLinearized()) {
5061 } else {
5063 }
5064}
5065
5066
5067// Production signal strengths at mu+ mu- colliders
5068// ------------------------------------------------
5069
5070mummZH::mummZH(const StandardModel& SM_i, const double sqrt_s_i)
5071: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5072{
5073 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5074 throw std::runtime_error("mummZH called with a class whose parent is not NPbase");
5075}
5076
5078{
5079 return myNPbase->mummZH(sqrt_s);
5080}
5081
5082
5083mummHvv::mummHvv(const StandardModel& SM_i, const double sqrt_s_i)
5084: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5085{
5086 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5087 throw std::runtime_error("mummHvv called with a class whose parent is not NPbase");
5088}
5089
5091{
5092 return myNPbase->mummHvv(sqrt_s);
5093}
5094
5095
5096mummHmm::mummHmm(const StandardModel& SM_i, const double sqrt_s_i)
5097: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5098{
5099 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5100 throw std::runtime_error("mummHmm called with a class whose parent is not NPbase");
5101}
5102
5104{
5105 return myNPbase->mummHmm(sqrt_s);
5106}
5107
5108
5109mummttH::mummttH(const StandardModel& SM_i, const double sqrt_s_i)
5110: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5111{
5112 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5113 throw std::runtime_error("mummttH called with a class whose parent is not NPbase");
5114}
5115
5117{
5118 return myNPbase->mummttH(sqrt_s);
5119}
5120
5121
5122// Full signal strengths at mu+ mu- colliders
5123// -------------------------------------------
5124
5125
5126mummHbb::mummHbb(const StandardModel& SM_i, const double sqrt_s_i)
5127: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5128{
5129 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5130 throw std::runtime_error("mummHbb called with a class whose parent is not NPbase");
5131}
5132
5134{
5135 if ((this->getModel()).isModelLinearized()) {
5136 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5137 } else {
5138 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHbbRatio());
5139 }
5140}
5141
5142mummHcc::mummHcc(const StandardModel& SM_i, const double sqrt_s_i)
5143: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5144{
5145 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5146 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
5147}
5148
5150{
5151 if ((this->getModel()).isModelLinearized()) {
5152 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5153 } else {
5154 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHccRatio());
5155 }
5156}
5157
5158mummHgg::mummHgg(const StandardModel& SM_i, const double sqrt_s_i)
5159: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5160{
5161 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5162 throw std::runtime_error("mummHgg called with a class whose parent is not NPbase");
5163}
5164
5166{
5167 if ((this->getModel()).isModelLinearized()) {
5168 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5169 } else {
5170 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHggRatio());
5171 }
5172}
5173
5174mummHWW::mummHWW(const StandardModel& SM_i, const double sqrt_s_i)
5175: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5176{
5177 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5178 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
5179}
5180
5182{
5183 if ((this->getModel()).isModelLinearized()) {
5184 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5185 } else {
5186 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHWWRatio());
5187 }
5188}
5189
5190mummHtautau::mummHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5191: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5192{
5193 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5194 throw std::runtime_error("mummHtautau called with a class whose parent is not NPbase");
5195}
5196
5198{
5199 if ((this->getModel()).isModelLinearized()) {
5200 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5201 } else {
5203 }
5204}
5205
5206mummHZZ::mummHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5207: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5208{
5209 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5210 throw std::runtime_error("mummHZZ called with a class whose parent is not NPbase");
5211}
5212
5214{
5215 if ((this->getModel()).isModelLinearized()) {
5216 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5217 } else {
5218 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZZRatio());
5219 }
5220}
5221
5222mummHZga::mummHZga(const StandardModel& SM_i, const double sqrt_s_i)
5223: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5224{
5225 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5226 throw std::runtime_error("mummHZga called with a class whose parent is not NPbase");
5227}
5228
5230{
5231 if ((this->getModel()).isModelLinearized()) {
5232 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5233 } else {
5234 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZgaRatio());
5235 }
5236}
5237
5238mummHgaga::mummHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5239: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5240{
5241 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5242 throw std::runtime_error("mummHgaga called with a class whose parent is not NPbase");
5243}
5244
5246{
5247 if ((this->getModel()).isModelLinearized()) {
5248 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5249 } else {
5250 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHgagaRatio());
5251 }
5252}
5253
5254mummHmumu::mummHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5255: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5256{
5257 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5258 throw std::runtime_error("mummHmumu called with a class whose parent is not NPbase");
5259}
5260
5262{
5263 if ((this->getModel()).isModelLinearized()) {
5264 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5265 } else {
5266 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHmumuRatio());
5267 }
5268}
5269
5270
5271
5272mummZHbb::mummZHbb(const StandardModel& SM_i, const double sqrt_s_i)
5273: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5274{
5275 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5276 throw std::runtime_error("mummZHbb called with a class whose parent is not NPbase");
5277}
5278
5280{
5281 if ((this->getModel()).isModelLinearized()) {
5282 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5283 } else {
5284 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHbbRatio());
5285 }
5286}
5287
5288mummZHcc::mummZHcc(const StandardModel& SM_i, const double sqrt_s_i)
5289: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5290{
5291 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5292 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5293}
5294
5296{
5297 if ((this->getModel()).isModelLinearized()) {
5298 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5299 } else {
5300 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHccRatio());
5301 }
5302}
5303
5304mummZHgg::mummZHgg(const StandardModel& SM_i, const double sqrt_s_i)
5305: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5306{
5307 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5308 throw std::runtime_error("mummZHgg called with a class whose parent is not NPbase");
5309}
5310
5312{
5313 if ((this->getModel()).isModelLinearized()) {
5314 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5315 } else {
5316 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHggRatio());
5317 }
5318}
5319
5320mummZHWW::mummZHWW(const StandardModel& SM_i, const double sqrt_s_i)
5321: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5322{
5323 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5324 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5325}
5326
5328{
5329 if ((this->getModel()).isModelLinearized()) {
5330 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5331 } else {
5332 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHWWRatio());
5333 }
5334}
5335
5336mummZHtautau::mummZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5337: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5338{
5339 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5340 throw std::runtime_error("mummZHtautau called with a class whose parent is not NPbase");
5341}
5342
5344{
5345 if ((this->getModel()).isModelLinearized()) {
5346 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5347 } else {
5349 }
5350}
5351
5352mummZHZZ::mummZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5353: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5354{
5355 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5356 throw std::runtime_error("mummZHZZ called with a class whose parent is not NPbase");
5357}
5358
5360{
5361 if ((this->getModel()).isModelLinearized()) {
5362 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5363 } else {
5364 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZZRatio());
5365 }
5366}
5367
5368mummZHZga::mummZHZga(const StandardModel& SM_i, const double sqrt_s_i)
5369: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5370{
5371 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5372 throw std::runtime_error("mummZHZga called with a class whose parent is not NPbase");
5373}
5374
5376{
5377 if ((this->getModel()).isModelLinearized()) {
5378 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5379 } else {
5380 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZgaRatio());
5381 }
5382}
5383
5384mummZHgaga::mummZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5385: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5386{
5387 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5388 throw std::runtime_error("mummZHgaga called with a class whose parent is not NPbase");
5389}
5390
5392{
5393 if ((this->getModel()).isModelLinearized()) {
5394 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5395 } else {
5396 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHgagaRatio());
5397 }
5398}
5399
5400mummZHmumu::mummZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5401: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5402{
5403 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5404 throw std::runtime_error("mummZHmumu called with a class whose parent is not NPbase");
5405}
5406
5408{
5409 if ((this->getModel()).isModelLinearized()) {
5410 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5411 } else {
5412 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHmumuRatio());
5413 }
5414}
5415
5416
5417
5418mummHvvbb::mummHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
5419: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5420{
5421 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5422 throw std::runtime_error("mummHvvbb called with a class whose parent is not NPbase");
5423}
5424
5426{
5427 if ((this->getModel()).isModelLinearized()) {
5428 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5429 } else {
5430 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHbbRatio());
5431 }
5432}
5433
5434mummHvvcc::mummHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
5435: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5436{
5437 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5438 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5439}
5440
5442{
5443 if ((this->getModel()).isModelLinearized()) {
5444 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5445 } else {
5446 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHccRatio());
5447 }
5448}
5449
5450mummHvvgg::mummHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
5451: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5452{
5453 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5454 throw std::runtime_error("mummHvvgg called with a class whose parent is not NPbase");
5455}
5456
5458{
5459 if ((this->getModel()).isModelLinearized()) {
5460 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5461 } else {
5462 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHggRatio());
5463 }
5464}
5465
5466mummHvvWW::mummHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
5467: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5468{
5469 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5470 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5471}
5472
5474{
5475 if ((this->getModel()).isModelLinearized()) {
5476 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5477 } else {
5478 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHWWRatio());
5479 }
5480}
5481
5482mummHvvtautau::mummHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
5483: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5484{
5485 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5486 throw std::runtime_error("mummHvvtautau called with a class whose parent is not NPbase");
5487}
5488
5490{
5491 if ((this->getModel()).isModelLinearized()) {
5492 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5493 } else {
5495 }
5496}
5497
5498mummHvvZZ::mummHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
5499: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5500{
5501 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5502 throw std::runtime_error("mummHvvZZ called with a class whose parent is not NPbase");
5503}
5504
5506{
5507 if ((this->getModel()).isModelLinearized()) {
5508 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5509 } else {
5510 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZZRatio());
5511 }
5512}
5513
5514mummHvvZga::mummHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
5515: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5516{
5517 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5518 throw std::runtime_error("mummHvvZga called with a class whose parent is not NPbase");
5519}
5520
5522{
5523 if ((this->getModel()).isModelLinearized()) {
5524 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5525 } else {
5526 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
5527 }
5528}
5529
5530mummHvvgaga::mummHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
5531: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5532{
5533 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5534 throw std::runtime_error("mummHvvgaga called with a class whose parent is not NPbase");
5535}
5536
5538{
5539 if ((this->getModel()).isModelLinearized()) {
5540 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5541 } else {
5543 }
5544}
5545
5546mummHvvmumu::mummHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
5547: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5548{
5549 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5550 throw std::runtime_error("mummHvvmumu called with a class whose parent is not NPbase");
5551}
5552
5554{
5555 if ((this->getModel()).isModelLinearized()) {
5556 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5557 } else {
5559 }
5560}
5561
5562
5563
5564mummHmmbb::mummHmmbb(const StandardModel& SM_i, const double sqrt_s_i)
5565: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5566{
5567 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5568 throw std::runtime_error("mummHmmbb called with a class whose parent is not NPbase");
5569}
5570
5572{
5573 if ((this->getModel()).isModelLinearized()) {
5574 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5575 } else {
5576 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHbbRatio());
5577 }
5578}
5579
5580mummHmmcc::mummHmmcc(const StandardModel& SM_i, const double sqrt_s_i)
5581: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5582{
5583 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5584 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5585}
5586
5588{
5589 if ((this->getModel()).isModelLinearized()) {
5590 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5591 } else {
5592 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHccRatio());
5593 }
5594}
5595
5596mummHmmgg::mummHmmgg(const StandardModel& SM_i, const double sqrt_s_i)
5597: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5598{
5599 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5600 throw std::runtime_error("mummHmmgg called with a class whose parent is not NPbase");
5601}
5602
5604{
5605 if ((this->getModel()).isModelLinearized()) {
5606 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5607 } else {
5608 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHggRatio());
5609 }
5610}
5611
5612mummHmmWW::mummHmmWW(const StandardModel& SM_i, const double sqrt_s_i)
5613: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5614{
5615 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5616 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5617}
5618
5620{
5621 if ((this->getModel()).isModelLinearized()) {
5622 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5623 } else {
5624 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHWWRatio());
5625 }
5626}
5627
5628mummHmmtautau::mummHmmtautau(const StandardModel& SM_i, const double sqrt_s_i)
5629: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5630{
5631 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5632 throw std::runtime_error("mummHmmtautau called with a class whose parent is not NPbase");
5633}
5634
5636{
5637 if ((this->getModel()).isModelLinearized()) {
5638 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5639 } else {
5641 }
5642}
5643
5644mummHmmZZ::mummHmmZZ(const StandardModel& SM_i, const double sqrt_s_i)
5645: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5646{
5647 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5648 throw std::runtime_error("mummHmmZZ called with a class whose parent is not NPbase");
5649}
5650
5652{
5653 if ((this->getModel()).isModelLinearized()) {
5654 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5655 } else {
5656 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZZRatio());
5657 }
5658}
5659
5660mummHmmZga::mummHmmZga(const StandardModel& SM_i, const double sqrt_s_i)
5661: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5662{
5663 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5664 throw std::runtime_error("mummHmmZga called with a class whose parent is not NPbase");
5665}
5666
5668{
5669 if ((this->getModel()).isModelLinearized()) {
5670 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5671 } else {
5672 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZgaRatio());
5673 }
5674}
5675
5676mummHmmgaga::mummHmmgaga(const StandardModel& SM_i, const double sqrt_s_i)
5677: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5678{
5679 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5680 throw std::runtime_error("mummHmmgaga called with a class whose parent is not NPbase");
5681}
5682
5684{
5685 if ((this->getModel()).isModelLinearized()) {
5686 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5687 } else {
5689 }
5690}
5691
5692mummHmmmumu::mummHmmmumu(const StandardModel& SM_i, const double sqrt_s_i)
5693: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5694{
5695 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5696 throw std::runtime_error("mummHmmmumu called with a class whose parent is not NPbase");
5697}
5698
5700{
5701 if ((this->getModel()).isModelLinearized()) {
5702 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5703 } else {
5705 }
5706}
5707
5708
5709mummttHbb::mummttHbb(const StandardModel& SM_i, const double sqrt_s_i)
5710: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5711{
5712 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5713 throw std::runtime_error("mummttHbb called with a class whose parent is not NPbase");
5714}
5715
5717{
5718 if ((this->getModel()).isModelLinearized()) {
5719 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5720 } else {
5721 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHbbRatio());
5722 }
5723}
5724
5725mummttHcc::mummttHcc(const StandardModel& SM_i, const double sqrt_s_i)
5726: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5727{
5728 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5729 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5730}
5731
5733{
5734 if ((this->getModel()).isModelLinearized()) {
5735 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5736 } else {
5737 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHccRatio());
5738 }
5739}
5740
5741mummttHgg::mummttHgg(const StandardModel& SM_i, const double sqrt_s_i)
5742: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5743{
5744 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5745 throw std::runtime_error("mummttHgg called with a class whose parent is not NPbase");
5746}
5747
5749{
5750 if ((this->getModel()).isModelLinearized()) {
5751 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5752 } else {
5753 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHggRatio());
5754 }
5755}
5756
5757mummttHWW::mummttHWW(const StandardModel& SM_i, const double sqrt_s_i)
5758: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5759{
5760 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5761 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5762}
5763
5765{
5766 if ((this->getModel()).isModelLinearized()) {
5767 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5768 } else {
5769 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHWWRatio());
5770 }
5771}
5772
5773mummttHtautau::mummttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5774: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5775{
5776 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5777 throw std::runtime_error("mummttHtautau called with a class whose parent is not NPbase");
5778}
5779
5781{
5782 if ((this->getModel()).isModelLinearized()) {
5783 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5784 } else {
5786 }
5787}
5788
5789mummttHZZ::mummttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5790: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5791{
5792 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5793 throw std::runtime_error("mummttHZZ called with a class whose parent is not NPbase");
5794}
5795
5797{
5798 if ((this->getModel()).isModelLinearized()) {
5799 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5800 } else {
5801 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZZRatio());
5802 }
5803}
5804
5805mummttHZga::mummttHZga(const StandardModel& SM_i, const double sqrt_s_i)
5806: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5807{
5808 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5809 throw std::runtime_error("mummttHZga called with a class whose parent is not NPbase");
5810}
5811
5813{
5814 if ((this->getModel()).isModelLinearized()) {
5815 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5816 } else {
5817 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZgaRatio());
5818 }
5819}
5820
5821mummttHgaga::mummttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5822: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5823{
5824 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5825 throw std::runtime_error("mummttHgaga called with a class whose parent is not NPbase");
5826}
5827
5829{
5830 if ((this->getModel()).isModelLinearized()) {
5831 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5832 } else {
5834 }
5835}
5836
5837mummttHmumu::mummttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5838: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5839{
5840 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5841 throw std::runtime_error("mummttHmumu called with a class whose parent is not NPbase");
5842}
5843
5845{
5846 if ((this->getModel()).isModelLinearized()) {
5847 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5848 } else {
5850 }
5851}
5852
5853
5854// The same in the narrow width approximation
5855
5856mummHbbNWA::mummHbbNWA(const StandardModel& SM_i, const double sqrt_s_i)
5857: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5858{
5859 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5860 throw std::runtime_error("mummHbbNWA called with a class whose parent is not NPbase");
5861}
5862
5864{
5865 if ((this->getModel()).isModelLinearized()) {
5866 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5867 } else {
5868 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHbbRatio());
5869 }
5870}
5871
5872mummHccNWA::mummHccNWA(const StandardModel& SM_i, const double sqrt_s_i)
5873: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5874{
5875 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5876 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5877}
5878
5880{
5881 if ((this->getModel()).isModelLinearized()) {
5882 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5883 } else {
5884 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHccRatio());
5885 }
5886}
5887
5888mummHggNWA::mummHggNWA(const StandardModel& SM_i, const double sqrt_s_i)
5889: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5890{
5891 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5892 throw std::runtime_error("mummHggNWA called with a class whose parent is not NPbase");
5893}
5894
5896{
5897 if ((this->getModel()).isModelLinearized()) {
5898 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5899 } else {
5900 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHggRatio());
5901 }
5902}
5903
5904mummHWWNWA::mummHWWNWA(const StandardModel& SM_i, const double sqrt_s_i)
5905: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5906{
5907 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5908 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5909}
5910
5912{
5913 if ((this->getModel()).isModelLinearized()) {
5914 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5915 } else {
5916 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHWWRatio());
5917 }
5918}
5919
5920mummHtautauNWA::mummHtautauNWA(const StandardModel& SM_i, const double sqrt_s_i)
5921: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5922{
5923 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5924 throw std::runtime_error("mummHtautauNWA called with a class whose parent is not NPbase");
5925}
5926
5928{
5929 if ((this->getModel()).isModelLinearized()) {
5930 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5931 } else {
5933 }
5934}
5935
5936mummHZZNWA::mummHZZNWA(const StandardModel& SM_i, const double sqrt_s_i)
5937: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5938{
5939 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5940 throw std::runtime_error("mummHZZNWA called with a class whose parent is not NPbase");
5941}
5942
5944{
5945 if ((this->getModel()).isModelLinearized()) {
5946 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5947 } else {
5948 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHZZRatio());
5949 }
5950}
5951
5952mummHZgaNWA::mummHZgaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5953: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5954{
5955 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5956 throw std::runtime_error("mummHZgaNWA called with a class whose parent is not NPbase");
5957}
5958
5960{
5961 if ((this->getModel()).isModelLinearized()) {
5962 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5963 } else {
5965 }
5966}
5967
5968mummHgagaNWA::mummHgagaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5969: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5970{
5971 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5972 throw std::runtime_error("mummHgagaNWA called with a class whose parent is not NPbase");
5973}
5974
5976{
5977 if ((this->getModel()).isModelLinearized()) {
5978 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5979 } else {
5981 }
5982}
5983
5984mummHmumuNWA::mummHmumuNWA(const StandardModel& SM_i, const double sqrt_s_i)
5985: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5986{
5987 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5988 throw std::runtime_error("mummHmumuNWA called with a class whose parent is not NPbase");
5989}
5990
5992{
5993 if ((this->getModel()).isModelLinearized()) {
5994 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5995 } else {
5997 }
5998}
5999
6000// Full signal strengths at ep colliders
6001// -------------------------------------
6002
6003muepWBFbb::muepWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
6004: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6005{
6006 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6007 throw std::runtime_error("muepWBFbb called with a class whose parent is not NPbase");
6008
6009}
6010
6012{
6013 if ((this->getModel()).isModelLinearized()) {
6014 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6015 } else {
6016 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHbbRatio());
6017 }
6018}
6019
6020muepWBFcc::muepWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
6021: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6022{
6023 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6024 throw std::runtime_error("muepWBFcc called with a class whose parent is not NPbase");
6025
6026}
6027
6029{
6030 if ((this->getModel()).isModelLinearized()) {
6031 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
6032 } else {
6033 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHccRatio());
6034 }
6035}
6036
6037muepWBFgg::muepWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
6038: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6039{
6040 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6041 throw std::runtime_error("muepWBFgg called with a class whose parent is not NPbase");
6042
6043}
6044
6046{
6047 if ((this->getModel()).isModelLinearized()) {
6048 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
6049 } else {
6050 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHggRatio());
6051 }
6052}
6053
6054muepWBFWW2l2v::muepWBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
6055: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6056{
6057 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6058 throw std::runtime_error("muepWBFWW2l2v called with a class whose parent is not NPbase");
6059
6060}
6061
6063{
6064 if ((this->getModel()).isModelLinearized()) {
6065 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
6066 } else {
6068 }
6069}
6070
6071muepWBFZZ4l::muepWBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
6072: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6073{
6074 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6075 throw std::runtime_error("muepWBFZZ4l called with a class whose parent is not NPbase");
6076
6077}
6078
6080{
6081 if ((this->getModel()).isModelLinearized()) {
6082 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6083 } else {
6084 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrH4lRatio());
6085 }
6086}
6087
6088muepWBFgaga::muepWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
6089: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6090{
6091 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6092 throw std::runtime_error("muepWBFgaga called with a class whose parent is not NPbase");
6093
6094}
6095
6097{
6098 if ((this->getModel()).isModelLinearized()) {
6099 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
6100 } else {
6102 }
6103}
6104
6105muepWBFtautau::muepWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
6106: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6107{
6108 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6109 throw std::runtime_error("muepWBFtautau called with a class whose parent is not NPbase");
6110
6111}
6112
6114{
6115 if ((this->getModel()).isModelLinearized()) {
6116 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
6117 } else {
6119 }
6120}
6121
6122muepZBFbb::muepZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
6123: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6124{
6125 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6126 throw std::runtime_error("muepZBFbb called with a class whose parent is not NPbase");
6127
6128}
6129
6131{
6132 if ((this->getModel()).isModelLinearized()) {
6133 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6134 } else {
6135 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHbbRatio());
6136 }
6137}
6138
6139muepZBFcc::muepZBFcc(const StandardModel& SM_i, const double sqrt_s_i)
6140: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6141{
6142 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6143 throw std::runtime_error("muepZBFcc called with a class whose parent is not NPbase");
6144
6145}
6146
6148{
6149 if ((this->getModel()).isModelLinearized()) {
6150 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
6151 } else {
6152 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHccRatio());
6153 }
6154}
6155
6156muepZBFgg::muepZBFgg(const StandardModel& SM_i, const double sqrt_s_i)
6157: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6158{
6159 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6160 throw std::runtime_error("muepZBFgg called with a class whose parent is not NPbase");
6161
6162}
6163
6165{
6166 if ((this->getModel()).isModelLinearized()) {
6167 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
6168 } else {
6169 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHggRatio());
6170 }
6171}
6172
6173muepZBFWW2l2v::muepZBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
6174: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6175{
6176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6177 throw std::runtime_error("muepZBFWW2l2v called with a class whose parent is not NPbase");
6178
6179}
6180
6182{
6183 if ((this->getModel()).isModelLinearized()) {
6184 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
6185 } else {
6187 }
6188}
6189
6190muepZBFZZ4l::muepZBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
6191: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6192{
6193 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6194 throw std::runtime_error("muepZBFZZ4l called with a class whose parent is not NPbase");
6195
6196}
6197
6199{
6200 if ((this->getModel()).isModelLinearized()) {
6201 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6202 } else {
6203 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrH4lRatio());
6204 }
6205}
6206
6207muepZBFgaga::muepZBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
6208: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6209{
6210 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6211 throw std::runtime_error("muepZBFgaga called with a class whose parent is not NPbase");
6212
6213}
6214
6216{
6217 if ((this->getModel()).isModelLinearized()) {
6218 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
6219 } else {
6221 }
6222}
6223
6224muepZBFtautau::muepZBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
6225: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6226{
6227 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6228 throw std::runtime_error("muepZBFtautau called with a class whose parent is not NPbase");
6229
6230}
6231
6233{
6234 if ((this->getModel()).isModelLinearized()) {
6235 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
6236 } else {
6238 }
6239}
6240
6241
6242// -----------------------------------------------------------------------------
6243// STXS bins
6244// -----------------------------------------------------------------------------
6245
6246// -----------------------------------------------------------------------------
6247// Stage 0
6248// -----------------------------------------------------------------------------
6249
6250STXS_0_qqH::STXS_0_qqH(const StandardModel& SM_i, const double sqrt_s_i)
6251: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6252{
6253 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6254 throw std::runtime_error("STXS_0_qqH called with a class whose parent is not NPbase");
6255
6256}
6257
6259{
6260 return myNPbase->STXS0_qqH(sqrt_s);
6261}
6262
6263
6264// -----------------------------------------------------------------------------
6265// Stage 1
6266// -----------------------------------------------------------------------------
6267
6269: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6270{
6271 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6272 throw std::runtime_error("STXSggH_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6273
6274}
6275
6277{
6278 if ((this->getModel()).isModelLinearized()) {
6279 return ((myNPbase->STXS_ggH_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6280 } else {
6282 }
6283}
6284
6285
6287: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6288{
6289 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6290 throw std::runtime_error("STXSggH_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6291
6292}
6293
6295{
6296 if ((this->getModel()).isModelLinearized()) {
6297 return ((myNPbase->STXS_ggH_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6298 } else {
6300 }
6301}
6302
6303
6304STXSggH0j4l::STXSggH0j4l(const StandardModel& SM_i, const double sqrt_s_i)
6305: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6306{
6307 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6308 throw std::runtime_error("STXSggH0j4l called with a class whose parent is not NPbase");
6309
6310}
6311
6313{
6314 if ((this->getModel()).isModelLinearized()) {
6315 return ((myNPbase->STXS_ggH0j(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6316 } else {
6318 }
6319}
6320
6322: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6323{
6324 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6325 throw std::runtime_error("STXSggH1j_pTH_0_60_4l called with a class whose parent is not NPbase");
6326
6327}
6328
6330{
6331 if ((this->getModel()).isModelLinearized()) {
6332 return ((myNPbase->STXS_ggH1j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6333 } else {
6335 }
6336}
6337
6339: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6340{
6341 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6342 throw std::runtime_error("STXSggH1j_pTH_60_120_4l called with a class whose parent is not NPbase");
6343
6344}
6345
6347{
6348 if ((this->getModel()).isModelLinearized()) {
6349 return ((myNPbase->STXS_ggH1j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6350 } else {
6352 }
6353}
6354
6356: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6357{
6358 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6359 throw std::runtime_error("STXSggH1j_pTH_120_200_4l called with a class whose parent is not NPbase");
6360
6361}
6362
6364{
6365 if ((this->getModel()).isModelLinearized()) {
6366 return ((myNPbase->STXS_ggH1j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6367 } else {
6369 }
6370}
6371
6373: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6374{
6375 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6376 throw std::runtime_error("STXSggH1j_pTH_200_4l called with a class whose parent is not NPbase");
6377
6378}
6379
6381{
6382 if ((this->getModel()).isModelLinearized()) {
6383 return ((myNPbase->STXS_ggH1j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6384 } else {
6386 }
6387}
6388
6390: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6391{
6392 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6393 throw std::runtime_error("STXSggH2j_pTH_0_200_4l called with a class whose parent is not NPbase");
6394
6395}
6396
6398{
6399 if ((this->getModel()).isModelLinearized()) {
6400 return ((myNPbase->STXS_ggH2j_pTH_0_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6401 } else {
6403 }
6404}
6405
6406
6408: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6409{
6410 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6411 throw std::runtime_error("STXSggH2j_pTH_0_60_4l called with a class whose parent is not NPbase");
6412
6413}
6414
6416{
6417 if ((this->getModel()).isModelLinearized()) {
6418 return ((myNPbase->STXS_ggH2j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6419 } else {
6421 }
6422}
6423
6424
6426: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6427{
6428 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6429 throw std::runtime_error("STXSggH2j_pTH_60_120_4l called with a class whose parent is not NPbase");
6430
6431}
6432
6434{
6435 if ((this->getModel()).isModelLinearized()) {
6436 return ((myNPbase->STXS_ggH2j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6437 } else {
6439 }
6440}
6441
6442
6444: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6445{
6446 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6447 throw std::runtime_error("STXSggH2j_pTH_120_200_4l called with a class whose parent is not NPbase");
6448
6449}
6450
6452{
6453 if ((this->getModel()).isModelLinearized()) {
6454 return ((myNPbase->STXS_ggH2j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6455 } else {
6457 }
6458}
6459
6460
6462: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6463{
6464 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6465 throw std::runtime_error("STXSggH2j_pTH_200_4l called with a class whose parent is not NPbase");
6466
6467}
6468
6470{
6471 if ((this->getModel()).isModelLinearized()) {
6472 return ((myNPbase->STXS_ggH2j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6473 } else {
6475 }
6476}
6477
6478
6480: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6481{
6482 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6483 throw std::runtime_error("STXSqqHqq_VBFtopo_Rest_4l called with a class whose parent is not NPbase");
6484
6485}
6486
6488{
6489 if ((this->getModel()).isModelLinearized()) {
6490 return ((myNPbase->STXS_qqHqq_VBFtopo_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6491 } else {
6493 }
6494}
6495
6496
6498: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6499{
6500 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6501 throw std::runtime_error("STXSqqHqq_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6502
6503}
6504
6506{
6507 if ((this->getModel()).isModelLinearized()) {
6508 return ((myNPbase->STXS_qqHqq_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6509 } else {
6511 }
6512}
6513
6514
6515
6517: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6518{
6519 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6520 throw std::runtime_error("STXSqqHqq_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6521
6522}
6523
6525{
6526 if ((this->getModel()).isModelLinearized()) {
6527 return ((myNPbase->STXS_qqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6528 } else {
6530 }
6531}
6532
6533
6534
6536: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6537{
6538 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6539 throw std::runtime_error("STXSqqHqq_nonVHtopo_4l called with a class whose parent is not NPbase");
6540
6541}
6542
6544{
6545 if ((this->getModel()).isModelLinearized()) {
6546 return ((myNPbase->STXS_qqHqq_nonVHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6547 } else {
6549 }
6550}
6551
6552
6553
6555: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6556{
6557 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6558 throw std::runtime_error("STXSqqHqq_VHtopo_4l called with a class whose parent is not NPbase");
6559
6560}
6561
6563{
6564 if ((this->getModel()).isModelLinearized()) {
6565 return ((myNPbase->STXS_qqHqq_VHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6566 } else {
6568 }
6569}
6570
6571
6572STXSqqHqq_Rest_4l::STXSqqHqq_Rest_4l(const StandardModel& SM_i, const double sqrt_s_i)
6573: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6574{
6575 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6576 throw std::runtime_error("STXSqqHqq_Rest_4l called with a class whose parent is not NPbase");
6577
6578}
6579
6581{
6582 if ((this->getModel()).isModelLinearized()) {
6583 return ((myNPbase->STXS_qqHqq_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6584 } else {
6586 }
6587}
6588
6589
6591: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6592{
6593 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6594 throw std::runtime_error("STXSqqHqq_pTj_200_4l called with a class whose parent is not NPbase");
6595
6596}
6597
6599{
6600 if ((this->getModel()).isModelLinearized()) {
6601 return ((myNPbase->STXS_qqHqq_pTj_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6602 } else {
6604 }
6605}
6606
6608: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6609{
6610 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6611 throw std::runtime_error("STXSqqHlv_pTV_0_250_4l called with a class whose parent is not NPbase");
6612
6613}
6614
6616{
6617 if ((this->getModel()).isModelLinearized()) {
6618 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6619 } else {
6621 }
6622}
6623
6624
6626: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6627{
6628 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6629 throw std::runtime_error("STXSqqHlv_pTV_0_150_4l called with a class whose parent is not NPbase");
6630
6631}
6632
6634{
6635 if ((this->getModel()).isModelLinearized()) {
6636 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6637 } else {
6639 }
6640}
6641
6642
6643
6645: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6646{
6647 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6648 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6649
6650}
6651
6653{
6654 if ((this->getModel()).isModelLinearized()) {
6656 } else {
6658 }
6659}
6660
6661
6662
6664: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6665{
6666 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6667 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6668
6669}
6670
6672{
6673 if ((this->getModel()).isModelLinearized()) {
6675 } else {
6677 }
6678}
6679
6680
6682: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6683{
6684 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6685 throw std::runtime_error("STXSqqHlv_pTV_250_4l called with a class whose parent is not NPbase");
6686
6687}
6688
6690{
6691 if ((this->getModel()).isModelLinearized()) {
6692 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6693 } else {
6695 }
6696}
6697
6699: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6700{
6701 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6702 throw std::runtime_error("STXSqqHll_pTV_0_150_4l called with a class whose parent is not NPbase");
6703
6704}
6705
6707{
6708 if ((this->getModel()).isModelLinearized()) {
6709 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6710 } else {
6712 }
6713}
6714
6716: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6717{
6718 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6719 throw std::runtime_error("STXSqqHll_pTV_150_250_4l called with a class whose parent is not NPbase");
6720
6721}
6722
6724{
6725 if ((this->getModel()).isModelLinearized()) {
6726 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6727 } else {
6729 }
6730}
6731
6732
6734: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6735{
6736 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6737 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6738
6739}
6740
6742{
6743 if ((this->getModel()).isModelLinearized()) {
6745 } else {
6747 }
6748}
6749
6750
6752: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6753{
6754 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6755 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6756
6757}
6758
6760{
6761 if ((this->getModel()).isModelLinearized()) {
6763 } else {
6765 }
6766}
6767
6768
6770: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6771{
6772 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6773 throw std::runtime_error("STXSqqHll_pTV_250_4l called with a class whose parent is not NPbase");
6774
6775}
6776
6778{
6779 if ((this->getModel()).isModelLinearized()) {
6780 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6781 } else {
6783 }
6784}
6785
6786STXSttHtH4l::STXSttHtH4l(const StandardModel& SM_i, const double sqrt_s_i)
6787: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6788{
6789 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6790 throw std::runtime_error("STXSttHtH4l called with a class whose parent is not NPbase");
6791
6792}
6793
6795{
6796 if ((this->getModel()).isModelLinearized()) {
6797 return ((myNPbase->STXS_ttHtH(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6798 } else {
6800 }
6801}
6802
6803
6805: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6806{
6807 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6808 throw std::runtime_error("STXSqqHlv_pTV_0_250_bb called with a class whose parent is not NPbase");
6809
6810}
6811
6813{
6814 if ((this->getModel()).isModelLinearized()) {
6815 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6816 } else {
6818 }
6819}
6820
6821
6823: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6824{
6825 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6826 throw std::runtime_error("STXSqqHlv_pTV_0_150_bb called with a class whose parent is not NPbase");
6827
6828}
6829
6831{
6832 if ((this->getModel()).isModelLinearized()) {
6833 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6834 } else {
6836 }
6837}
6838
6839
6840
6842: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6843{
6844 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6845 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6846
6847}
6848
6850{
6851 if ((this->getModel()).isModelLinearized()) {
6853 } else {
6855 }
6856}
6857
6858
6859
6861: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6862{
6863 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6864 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6865
6866}
6867
6869{
6870 if ((this->getModel()).isModelLinearized()) {
6872 } else {
6874 }
6875}
6876
6877
6879: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6880{
6881 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6882 throw std::runtime_error("STXSqqHlv_pTV_250_bb called with a class whose parent is not NPbase");
6883
6884}
6885
6887{
6888 if ((this->getModel()).isModelLinearized()) {
6889 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6890 } else {
6892 }
6893}
6894
6896: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6897{
6898 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6899 throw std::runtime_error("STXSqqHll_pTV_0_150_bb called with a class whose parent is not NPbase");
6900
6901}
6902
6904{
6905 if ((this->getModel()).isModelLinearized()) {
6906 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6907 } else {
6909 }
6910}
6911
6913: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6914{
6915 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6916 throw std::runtime_error("STXSqqHll_pTV_150_250_bb called with a class whose parent is not NPbase");
6917
6918}
6919
6921{
6922 if ((this->getModel()).isModelLinearized()) {
6923 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6924 } else {
6926 }
6927}
6928
6929
6931: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6932{
6933 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6934 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6935
6936}
6937
6939{
6940 if ((this->getModel()).isModelLinearized()) {
6942 } else {
6944 }
6945}
6946
6947
6949: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6950{
6951 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6952 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6953
6954}
6955
6957{
6958 if ((this->getModel()).isModelLinearized()) {
6960 } else {
6962 }
6963}
6964
6965
6967: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6968{
6969 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6970 throw std::runtime_error("STXSqqHll_pTV_250_bb called with a class whose parent is not NPbase");
6971
6972}
6973
6975{
6976 if ((this->getModel()).isModelLinearized()) {
6977 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6978 } else {
6980 }
6981}
6982
6983
6985: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6986{
6987 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6988 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6989
6990}
6991
6993{
6994 if ((this->getModel()).isModelLinearized()) {
6996 } else {
6998 }
6999}
7000
7001
7003: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7004{
7005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7006 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
7007
7008}
7009
7011{
7012 if ((this->getModel()).isModelLinearized()) {
7013 return ((myNPbase->STXS_WHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7014 } else {
7016 }
7017}
7018
7019
7021: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7022{
7023 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7024 throw std::runtime_error("STXSWHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
7025
7026}
7027
7029{
7030 if ((this->getModel()).isModelLinearized()) {
7031 return ((myNPbase->STXS_WHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7032 } else {
7034 }
7035}
7036
7037
7039: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7040{
7041 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7042 throw std::runtime_error("STXSWHqqHqq_Rest_2b called with a class whose parent is not NPbase");
7043
7044}
7045
7047{
7048 if ((this->getModel()).isModelLinearized()) {
7049 return ((myNPbase->STXS_WHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7050 } else {
7052 }
7053}
7054
7055
7057: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7058{
7059 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7060 throw std::runtime_error("STXSWHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
7061
7062}
7063
7065{
7066 if ((this->getModel()).isModelLinearized()) {
7067 return ((myNPbase->STXS_WHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7068 } else {
7070 }
7071}
7072
7073
7075: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7076{
7077 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7078 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
7079
7080}
7081
7083{
7084 if ((this->getModel()).isModelLinearized()) {
7086 } else {
7088 }
7089}
7090
7091
7093: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7094{
7095 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7096 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
7097
7098}
7099
7101{
7102 if ((this->getModel()).isModelLinearized()) {
7103 return ((myNPbase->STXS_ZHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7104 } else {
7106 }
7107}
7108
7109
7111: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7112{
7113 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7114 throw std::runtime_error("STXSZHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
7115
7116}
7117
7119{
7120 if ((this->getModel()).isModelLinearized()) {
7121 return ((myNPbase->STXS_ZHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7122 } else {
7124 }
7125}
7126
7127
7129: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7130{
7131 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7132 throw std::runtime_error("STXSZHqqHqq_Rest_2b called with a class whose parent is not NPbase");
7133
7134}
7135
7137{
7138 if ((this->getModel()).isModelLinearized()) {
7139 return ((myNPbase->STXS_ZHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7140 } else {
7142 }
7143}
7144
7145
7147: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7148{
7149 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7150 throw std::runtime_error("STXSZHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
7151
7152}
7153
7155{
7156 if ((this->getModel()).isModelLinearized()) {
7157 return ((myNPbase->STXS_ZHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7158 } else {
7160 }
7161}
7162
7163
7164
7165// -----------------------------------------------------------------------------
7166// Stage 1.2
7167// -----------------------------------------------------------------------------
7168
7169STXS12_ggH_pTH200_300_Nj01::STXS12_ggH_pTH200_300_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7170: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7171{
7172 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7173 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with a class whose parent is not NPbase");
7174
7175}
7176
7178{
7179 double BrHXXRatio = 1.0;
7180 if (fstate == 1){
7181 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7182 } else if (fstate == 2){
7183 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7184 } else if (fstate == 3){
7185 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7186 } else if (fstate == 4){
7187 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7188 } else {
7189 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with invalid argument for final state in fstate_i");
7190 }
7191
7192 if ((this->getModel()).isModelLinearized()) {
7193 return ((myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7194 } else {
7195 return (myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s))*(BrHXXRatio);
7196 }
7197}
7198
7199// -----------------------------------------------------------------------------
7200
7201STXS12_ggH_pTH300_450_Nj01::STXS12_ggH_pTH300_450_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7202: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7203{
7204 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7205 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with a class whose parent is not NPbase");
7206
7207}
7208
7210{
7211 double BrHXXRatio = 1.0;
7212 if (fstate == 1){
7213 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7214 } else if (fstate == 2){
7215 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7216 } else if (fstate == 3){
7217 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7218 } else if (fstate == 4){
7219 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7220 } else {
7221 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with invalid argument for final state in fstate_i");
7222 }
7223
7224 if ((this->getModel()).isModelLinearized()) {
7225 return ((myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7226 } else {
7227 return (myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s))*(BrHXXRatio);
7228 }
7229}
7230
7231// -----------------------------------------------------------------------------
7232
7233STXS12_ggH_pTH450_650_Nj01::STXS12_ggH_pTH450_650_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7234: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7235{
7236 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7237 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with a class whose parent is not NPbase");
7238
7239}
7240
7242{
7243 double BrHXXRatio = 1.0;
7244 if (fstate == 1){
7245 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7246 } else if (fstate == 2){
7247 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7248 } else if (fstate == 3){
7249 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7250 } else if (fstate == 4){
7251 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7252 } else {
7253 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with invalid argument for final state in fstate_i");
7254 }
7255
7256 if ((this->getModel()).isModelLinearized()) {
7257 return ((myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7258 } else {
7259 return (myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s))*(BrHXXRatio);
7260 }
7261}
7262
7263// -----------------------------------------------------------------------------
7264
7265STXS12_ggH_pTH650_Inf_Nj01::STXS12_ggH_pTH650_Inf_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7266: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7267{
7268 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7269 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with a class whose parent is not NPbase");
7270
7271}
7272
7274{
7275 double BrHXXRatio = 1.0;
7276 if (fstate == 1){
7277 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7278 } else if (fstate == 2){
7279 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7280 } else if (fstate == 3){
7281 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7282 } else if (fstate == 4){
7283 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7284 } else {
7285 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with invalid argument for final state in fstate_i");
7286 }
7287
7288 if ((this->getModel()).isModelLinearized()) {
7289 return ((myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7290 } else {
7291 return (myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s))*(BrHXXRatio);
7292 }
7293}
7294
7295
7296// -----------------------------------------------------------------------------
7297
7298STXS12_ggH_pTH10_Inf_Nj0::STXS12_ggH_pTH10_Inf_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7299: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7300{
7301 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7302 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with a class whose parent is not NPbase");
7303
7304}
7305
7307{
7308 //-- Production:
7309 double weight = 1.0; //If normalized to the SM
7310
7311 double muProd = myNPbase->STXS12_ggH_pTH10_Inf_Nj0(sqrt_s);
7312 double muProd1 = muProd -1.0;
7313 double muProd2 = 0.0;
7314 //-- Decay:
7315 double BrHXXRatio = 1.0;
7316 double dBrHXXRatio1 = 0.0;
7317 double dBrHXXRatio2 = 0.0;
7318
7319 if (fstate == 1){
7320 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7321 dBrHXXRatio1 = BrHXXRatio - 1.0;
7322 dBrHXXRatio2 = 0.0;
7323 } else if (fstate == 2){
7324 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7325 dBrHXXRatio1 = BrHXXRatio - 1.0;
7326 dBrHXXRatio2 = 0.0;
7327 } else if (fstate == 3){
7328 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7329 dBrHXXRatio1 = BrHXXRatio - 1.0;
7330 dBrHXXRatio2 = 0.0;
7331 } else if (fstate == 4){
7332 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7333 dBrHXXRatio1 = BrHXXRatio - 1.0;
7334 dBrHXXRatio2 = 0.0;
7335 } else {
7336 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with invalid argument for final state in fstate_i");
7337 }
7338
7339 //-- Production x Decay:
7340 if ((this->getModel()).isModelLinearized()){
7341 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7342 } else if((this->getModel()).isModelNPquadratic()){
7343 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7344 } else {
7345 return weight*(muProd)*(BrHXXRatio);
7346 }
7347}
7348
7349
7350
7351
7352
7353// -----------------------------------------------------------------------------
7354
7355//VM:STXS2024;
7356STXS12_ggH_pTH0_10_Nj0::STXS12_ggH_pTH0_10_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7357: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7358{
7359 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7360 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with a class whose parent is not NPbase");
7361
7362}
7363
7365{
7366 //-- Production:
7367 double weight = 1.0; //If normalized to the SM
7368 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7369 double muProd = myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s);
7370 double muProd1 = muProd -1.0;
7371 double muProd2 = 0.0;
7372
7373 //-- Decay:
7374 double BrHXXRatio = 1.0;
7375 double dBrHXXRatio1 = 0.0;
7376 double dBrHXXRatio2 = 0.0;
7377 if (fstate==0){
7378 // Use for Cross-section [pb] with no Higgs-boson decay
7379 weight = (6.6369); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7380 } else if (fstate == 1){
7381 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7382 dBrHXXRatio1 = BrHXXRatio - 1.0;
7383 dBrHXXRatio2 = 0.0;
7384 } else if (fstate == 2){
7385 BrHXXRatio = (myNPbase->BrHgagaRatio());
7386 dBrHXXRatio1 = BrHXXRatio - 1.0;
7387 dBrHXXRatio2 = 0.0;
7388 } else if (fstate == 3){
7389 BrHXXRatio = (myNPbase->BrHbbRatio());
7390 dBrHXXRatio1 = BrHXXRatio - 1.0;
7391 dBrHXXRatio2 = 0.0;
7392 } else if (fstate == 4){
7393 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7394 dBrHXXRatio1 = BrHXXRatio - 1.0;
7395 dBrHXXRatio2 = 0.0;
7396 } else if (fstate == 5){
7397 BrHXXRatio = (myNPbase->BrHtautauRatio());
7398 dBrHXXRatio1 = BrHXXRatio - 1.0;
7399 dBrHXXRatio2 = 0.0;
7400 } else if (fstate == 6){
7401 BrHXXRatio = (myNPbase->BrHWWRatio());
7402 dBrHXXRatio1 = BrHXXRatio - 1.0;
7403 dBrHXXRatio2 = 0.0;
7404 } else if (fstate == 7){
7405 BrHXXRatio = (myNPbase->BrHZZRatio());
7406 dBrHXXRatio1 = BrHXXRatio - 1.0;
7407 dBrHXXRatio2 = 0.0;
7408 } else {
7409 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with invalid argument for final state in fstate_i");
7410 }
7411
7412 //-- Production x Decay:
7413 if ((this->getModel()).isModelLinearized()){
7414 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7415 } else if((this->getModel()).isModelNPquadratic()){
7416 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7417 } else {
7418 return weight*(muProd)*(BrHXXRatio);
7419 }
7420
7421}
7422
7423
7424
7425// -----------------------------------------------------------------------------
7426
7427//VM:STXS2024;
7428STXS12_ggH_pTH10_200_Nj0::STXS12_ggH_pTH10_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7429: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7430{
7431 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7432 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with a class whose parent is not NPbase");
7433
7434}
7435
7437{
7438 //-- Production:
7439 double weight = 1.0; //If normalized to the SM
7440 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7441 double muProd = myNPbase->STXS12_ggH_pTH10_200_Nj0(sqrt_s);
7442 double muProd1 = muProd -1.0;
7443 double muProd2 = 0.0;
7444
7445 //-- Decay:
7446 double BrHXXRatio = 1.0;
7447 double dBrHXXRatio1 = 0.0;
7448 double dBrHXXRatio2 = 0.0;
7449 if (fstate==0){
7450 // Use for Cross-section [pb] with no Higgs-boson decay
7451 weight = (20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7452 } else if (fstate == 1){
7453 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7454 dBrHXXRatio1 = BrHXXRatio - 1.0;
7455 dBrHXXRatio2 = 0.0;
7456 } else if (fstate == 2){
7457 BrHXXRatio = (myNPbase->BrHgagaRatio());
7458 dBrHXXRatio1 = BrHXXRatio - 1.0;
7459 dBrHXXRatio2 = 0.0;
7460 } else if (fstate == 3){
7461 BrHXXRatio = (myNPbase->BrHbbRatio());
7462 dBrHXXRatio1 = BrHXXRatio - 1.0;
7463 dBrHXXRatio2 = 0.0;
7464 } else if (fstate == 4){
7465 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7466 dBrHXXRatio1 = BrHXXRatio - 1.0;
7467 dBrHXXRatio2 = 0.0;
7468 } else if (fstate == 5){
7469 BrHXXRatio = (myNPbase->BrHtautauRatio());
7470 dBrHXXRatio1 = BrHXXRatio - 1.0;
7471 dBrHXXRatio2 = 0.0;
7472 } else if (fstate == 6){
7473 BrHXXRatio = (myNPbase->BrHWWRatio());
7474 dBrHXXRatio1 = BrHXXRatio - 1.0;
7475 dBrHXXRatio2 = 0.0;
7476 } else if (fstate == 7){
7477 BrHXXRatio = (myNPbase->BrHZZRatio());
7478 dBrHXXRatio1 = BrHXXRatio - 1.0;
7479 dBrHXXRatio2 = 0.0;
7480 } else {
7481 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with invalid argument for final state in fstate_i");
7482 }
7483
7484 //-- Production x Decay:
7485 if ((this->getModel()).isModelLinearized()){
7486 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7487 } else if((this->getModel()).isModelNPquadratic()){
7488 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7489 } else {
7490 return weight*(muProd)*(BrHXXRatio);
7491 }
7492
7493}
7494
7495
7496
7497
7498// -----------------------------------------------------------------------------
7499
7500//VM:STXS2024;
7501STXS12_ggH_pTH0_200_Nj0::STXS12_ggH_pTH0_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7502: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7503{
7504 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7505 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with a class whose parent is not NPbase");
7506
7507}
7508
7510{
7511 //-- Production:
7512 double weight = 1.0; //If normalized to the SM
7513 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7514 double muProd = ( 6.6369*(myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s)) +
7516 /(6.6369 + 20.642);
7517 double muProd1 = muProd -1.0;
7518 double muProd2 = 0.0;
7519
7520 //-- Decay:
7521 double BrHXXRatio = 1.0;
7522 double dBrHXXRatio1 = 0.0;
7523 double dBrHXXRatio2 = 0.0;
7524 if (fstate==0){
7525 // Use for Cross-section [pb] with no Higgs-boson decay
7526 weight = (6.6369 + 20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7527 } else if (fstate == 1){
7528 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7529 dBrHXXRatio1 = BrHXXRatio - 1.0;
7530 dBrHXXRatio2 = 0.0;
7531 } else if (fstate == 2){
7532 BrHXXRatio = (myNPbase->BrHgagaRatio());
7533 dBrHXXRatio1 = BrHXXRatio - 1.0;
7534 dBrHXXRatio2 = 0.0;
7535 } else if (fstate == 3){
7536 BrHXXRatio = (myNPbase->BrHbbRatio());
7537 dBrHXXRatio1 = BrHXXRatio - 1.0;
7538 dBrHXXRatio2 = 0.0;
7539 } else if (fstate == 4){
7540 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7541 dBrHXXRatio1 = BrHXXRatio - 1.0;
7542 dBrHXXRatio2 = 0.0;
7543 } else if (fstate == 5){
7544 BrHXXRatio = (myNPbase->BrHtautauRatio());
7545 dBrHXXRatio1 = BrHXXRatio - 1.0;
7546 dBrHXXRatio2 = 0.0;
7547 } else if (fstate == 6){
7548 BrHXXRatio = (myNPbase->BrHWWRatio());
7549 dBrHXXRatio1 = BrHXXRatio - 1.0;
7550 dBrHXXRatio2 = 0.0;
7551 } else if (fstate == 7){
7552 BrHXXRatio = (myNPbase->BrHZZRatio());
7553 dBrHXXRatio1 = BrHXXRatio - 1.0;
7554 dBrHXXRatio2 = 0.0;
7555 } else {
7556 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with invalid argument for final state in fstate_i");
7557 }
7558
7559 //-- Production x Decay:
7560 if ((this->getModel()).isModelLinearized()){
7561 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7562 } else if((this->getModel()).isModelNPquadratic()){
7563 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7564 } else {
7565 return weight*(muProd)*(BrHXXRatio);
7566 }
7567
7568}
7569
7570
7571
7572
7573// -----------------------------------------------------------------------------
7574
7575//VM:STXS2024;
7576STXS12_ggH_mjj0_350_pTH0_60_Nj1::STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7577: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7578{
7579 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7580 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7581
7582}
7583
7585{
7586 //-- Production:
7587 double weight = 1.0; //If normalized to the SM
7588 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7589
7590 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj1(sqrt_s)) );
7591 double muProd1 = muProd -1.0;
7592 double muProd2 = 0.0;
7593
7594 //-- Decay:
7595 double BrHXXRatio = 1.0;
7596 double dBrHXXRatio1 = 0.0;
7597 double dBrHXXRatio2 = 0.0;
7598 if (fstate==0){
7599 // Use for Cross-section [pb] with no Higgs-boson decay
7600 weight = (1.); //NOT in Ref: https://www.hepdata.net/record/ins2104706 Figure7. Missing SM prediction!!!
7601 } else if (fstate == 1){
7602 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7603 dBrHXXRatio1 = BrHXXRatio - 1.0;
7604 dBrHXXRatio2 = 0.0;
7605 } else if (fstate == 2){
7606 BrHXXRatio = (myNPbase->BrHgagaRatio());
7607 dBrHXXRatio1 = BrHXXRatio - 1.0;
7608 dBrHXXRatio2 = 0.0;
7609 } else if (fstate == 3){
7610 BrHXXRatio = (myNPbase->BrHbbRatio());
7611 dBrHXXRatio1 = BrHXXRatio - 1.0;
7612 dBrHXXRatio2 = 0.0;
7613 } else if (fstate == 4){
7614 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7615 dBrHXXRatio1 = BrHXXRatio - 1.0;
7616 dBrHXXRatio2 = 0.0;
7617 } else if (fstate == 5){
7618 BrHXXRatio = (myNPbase->BrHtautauRatio());
7619 dBrHXXRatio1 = BrHXXRatio - 1.0;
7620 dBrHXXRatio2 = 0.0;
7621 } else if (fstate == 6){
7622 BrHXXRatio = (myNPbase->BrHWWRatio());
7623 dBrHXXRatio1 = BrHXXRatio - 1.0;
7624 dBrHXXRatio2 = 0.0;
7625 } else if (fstate == 7){
7626 BrHXXRatio = (myNPbase->BrHZZRatio());
7627 dBrHXXRatio1 = BrHXXRatio - 1.0;
7628 dBrHXXRatio2 = 0.0;
7629 } else {
7630 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj1 called with invalid argument for final state in fstate_i");
7631 }
7632
7633 //-- Production x Decay:
7634 if ((this->getModel()).isModelLinearized()){
7635 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7636 } else if((this->getModel()).isModelNPquadratic()){
7637 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7638 } else {
7639 return weight*(muProd)*(BrHXXRatio);
7640 }
7641
7642}
7643
7644
7645
7646
7647
7648
7649
7650// -----------------------------------------------------------------------------
7651
7652//AG:STXS2024
7653STXS12_ggH_pTH0_60_Nj1::STXS12_ggH_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7654: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7655{
7656 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7657 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7658
7659}
7660
7662{
7663 //-- Production:
7664 double weight = 1.0; //If normalized to the SM
7665 double muProd = myNPbase->STXS12_ggH_pTH0_60_Nj1(sqrt_s);
7666 double muProd1 = muProd -1.0;
7667 double muProd2 = 0.0;
7668
7669 //-- Decay:
7670 double BrHXXRatio = 1.0;
7671 double dBrHXXRatio1 = 0.0;
7672 double dBrHXXRatio2 = 0.0;
7673 if (fstate==0){
7674 // Use for Cross-section [pb] with no Higgs-boson decay
7675 weight = 6.50045; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7676 } else if (fstate == 1){
7677 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7678 dBrHXXRatio1 = BrHXXRatio - 1.0;
7679 dBrHXXRatio2 = 0.0;
7680 } else if (fstate == 2){
7681 BrHXXRatio = (myNPbase->BrHgagaRatio());
7682 dBrHXXRatio1 = BrHXXRatio - 1.0;
7683 dBrHXXRatio2 = 0.0;
7684 } else if (fstate == 3){
7685 BrHXXRatio = (myNPbase->BrHbbRatio());
7686 dBrHXXRatio1 = BrHXXRatio - 1.0;
7687 dBrHXXRatio2 = 0.0;
7688 } else if (fstate == 4){
7689 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7690 dBrHXXRatio1 = BrHXXRatio - 1.0;
7691 dBrHXXRatio2 = 0.0;
7692 } else if (fstate == 5){
7693 BrHXXRatio = (myNPbase->BrHtautauRatio());
7694 dBrHXXRatio1 = BrHXXRatio - 1.0;
7695 dBrHXXRatio2 = 0.0;
7696 } else if (fstate == 6){
7697 BrHXXRatio = (myNPbase->BrHWWRatio());
7698 dBrHXXRatio1 = BrHXXRatio - 1.0;
7699 dBrHXXRatio2 = 0.0;
7700 } else if (fstate == 7){
7701 BrHXXRatio = (myNPbase->BrHZZRatio());
7702 dBrHXXRatio1 = BrHXXRatio - 1.0;
7703 dBrHXXRatio2 = 0.0;
7704 } else {
7705 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with invalid argument for final state in fstate_i");
7706 }
7707
7708 //-- Production x Decay:
7709 if ((this->getModel()).isModelLinearized()){
7710 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7711 } else if((this->getModel()).isModelNPquadratic()){
7712 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7713 } else {
7714 return weight*(muProd)*(BrHXXRatio);
7715 }
7716
7717}
7718
7719// -----------------------------------------------------------------------------
7720
7721//AG:STXS2024
7722STXS12_ggH_pTH60_120_Nj1::STXS12_ggH_pTH60_120_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7723: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7724{
7725 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7726 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with a class whose parent is not NPbase");
7727
7728}
7729
7731{
7732 //-- Production:
7733 double weight = 1.0; //If normalized to the SM
7734 double muProd = myNPbase->STXS12_ggH_pTH60_120_Nj1(sqrt_s);
7735 double muProd1 = muProd -1.0;
7736 double muProd2 = 0.0;
7737
7738 //-- Decay:
7739 double BrHXXRatio = 1.0;
7740 double dBrHXXRatio1 = 0.0;
7741 double dBrHXXRatio2 = 0.0;
7742 if (fstate==0){
7743 // Use for Cross-section [pb] with no Higgs-boson decay
7744 weight = 4.50294; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7745 } else if (fstate == 1){
7746 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7747 dBrHXXRatio1 = BrHXXRatio - 1.0;
7748 dBrHXXRatio2 = 0.0;
7749 } else if (fstate == 2){
7750 BrHXXRatio = (myNPbase->BrHgagaRatio());
7751 dBrHXXRatio1 = BrHXXRatio - 1.0;
7752 dBrHXXRatio2 = 0.0;
7753 } else if (fstate == 3){
7754 BrHXXRatio = (myNPbase->BrHbbRatio());
7755 dBrHXXRatio1 = BrHXXRatio - 1.0;
7756 dBrHXXRatio2 = 0.0;
7757 } else if (fstate == 4){
7758 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7759 dBrHXXRatio1 = BrHXXRatio - 1.0;
7760 dBrHXXRatio2 = 0.0;
7761 } else if (fstate == 5){
7762 BrHXXRatio = (myNPbase->BrHtautauRatio());
7763 dBrHXXRatio1 = BrHXXRatio - 1.0;
7764 dBrHXXRatio2 = 0.0;
7765 } else if (fstate == 6){
7766 BrHXXRatio = (myNPbase->BrHWWRatio());
7767 dBrHXXRatio1 = BrHXXRatio - 1.0;
7768 dBrHXXRatio2 = 0.0;
7769 } else if (fstate == 7){
7770 BrHXXRatio = (myNPbase->BrHZZRatio());
7771 dBrHXXRatio1 = BrHXXRatio - 1.0;
7772 dBrHXXRatio2 = 0.0;
7773 } else {
7774 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with invalid argument for final state in fstate_i");
7775 }
7776
7777 //-- Production x Decay:
7778 if ((this->getModel()).isModelLinearized()){
7779 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7780 } else if((this->getModel()).isModelNPquadratic()){
7781 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7782 } else {
7783 return weight*(muProd)*(BrHXXRatio);
7784 }
7785
7786}
7787
7788// -----------------------------------------------------------------------------
7789
7790//AG:STXS2024
7791STXS12_ggH_pTH120_200_Nj1::STXS12_ggH_pTH120_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7792: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7793{
7794 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7795 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with a class whose parent is not NPbase");
7796
7797}
7798
7800{
7801 //-- Production:
7802 double weight = 1.0; //If normalized to the SM
7803 double muProd = myNPbase->STXS12_ggH_pTH120_200_Nj1(sqrt_s);
7804 double muProd1 = muProd -1.0;
7805 double muProd2 = 0.0;
7806
7807 //-- Decay:
7808 double BrHXXRatio = 1.0;
7809 double dBrHXXRatio1 = 0.0;
7810 double dBrHXXRatio2 = 0.0;
7811 if (fstate==0){
7812 // Use for Cross-section [pb] with no Higgs-boson decay
7813 weight = 0.74712; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7814 } else if (fstate == 1){
7815 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7816 dBrHXXRatio1 = BrHXXRatio - 1.0;
7817 dBrHXXRatio2 = 0.0;
7818 } else if (fstate == 2){
7819 BrHXXRatio = (myNPbase->BrHgagaRatio());
7820 dBrHXXRatio1 = BrHXXRatio - 1.0;
7821 dBrHXXRatio2 = 0.0;
7822 } else if (fstate == 3){
7823 BrHXXRatio = (myNPbase->BrHbbRatio());
7824 dBrHXXRatio1 = BrHXXRatio - 1.0;
7825 dBrHXXRatio2 = 0.0;
7826 } else if (fstate == 4){
7827 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7828 dBrHXXRatio1 = BrHXXRatio - 1.0;
7829 dBrHXXRatio2 = 0.0;
7830 } else if (fstate == 5){
7831 BrHXXRatio = (myNPbase->BrHtautauRatio());
7832 dBrHXXRatio1 = BrHXXRatio - 1.0;
7833 dBrHXXRatio2 = 0.0;
7834 } else if (fstate == 6){
7835 BrHXXRatio = (myNPbase->BrHWWRatio());
7836 dBrHXXRatio1 = BrHXXRatio - 1.0;
7837 dBrHXXRatio2 = 0.0;
7838 } else if (fstate == 7){
7839 BrHXXRatio = (myNPbase->BrHZZRatio());
7840 dBrHXXRatio1 = BrHXXRatio - 1.0;
7841 dBrHXXRatio2 = 0.0;
7842 } else {
7843 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with invalid argument for final state in fstate_i");
7844 }
7845
7846 //-- Production x Decay:
7847 if ((this->getModel()).isModelLinearized()){
7848 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7849 } else if((this->getModel()).isModelNPquadratic()){
7850 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7851 } else {
7852 return weight*(muProd)*(BrHXXRatio);
7853 }
7854
7855}
7856
7857
7858
7859// -----------------------------------------------------------------------------
7860
7861//VM:STXS2025
7862STXS12_ggH_pTH60_200_Nj1::STXS12_ggH_pTH60_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7863: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7864{
7865 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7866 throw std::runtime_error("STXS12_ggH_pTH60_200_Nj1 called with a class whose parent is not NPbase");
7867
7868}
7869
7871{
7872 //-- Production:
7873 double weight = 1.0; //If normalized to the SM
7874 double muProd = (4.50294*(myNPbase->STXS12_ggH_pTH60_120_Nj1(sqrt_s))+
7876 )/(4.50294+0.74712);
7877 double muProd1 = muProd -1.0;
7878 double muProd2 = 0.0;
7879
7880 //-- Decay:
7881 double BrHXXRatio = 1.0;
7882 double dBrHXXRatio1 = 0.0;
7883 double dBrHXXRatio2 = 0.0;
7884 if (fstate==0){
7885 // Use for Cross-section [pb] with no Higgs-boson decay
7886 weight = (4.50294+0.74712); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7887 } else if (fstate == 1){
7888 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7889 dBrHXXRatio1 = BrHXXRatio - 1.0;
7890 dBrHXXRatio2 = 0.0;
7891 } else if (fstate == 2){
7892 BrHXXRatio = (myNPbase->BrHgagaRatio());
7893 dBrHXXRatio1 = BrHXXRatio - 1.0;
7894 dBrHXXRatio2 = 0.0;
7895 } else if (fstate == 3){
7896 BrHXXRatio = (myNPbase->BrHbbRatio());
7897 dBrHXXRatio1 = BrHXXRatio - 1.0;
7898 dBrHXXRatio2 = 0.0;
7899 } else if (fstate == 4){
7900 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7901 dBrHXXRatio1 = BrHXXRatio - 1.0;
7902 dBrHXXRatio2 = 0.0;
7903 } else if (fstate == 5){
7904 BrHXXRatio = (myNPbase->BrHtautauRatio());
7905 dBrHXXRatio1 = BrHXXRatio - 1.0;
7906 dBrHXXRatio2 = 0.0;
7907 } else if (fstate == 6){
7908 BrHXXRatio = (myNPbase->BrHWWRatio());
7909 dBrHXXRatio1 = BrHXXRatio - 1.0;
7910 dBrHXXRatio2 = 0.0;
7911 } else if (fstate == 7){
7912 BrHXXRatio = (myNPbase->BrHZZRatio());
7913 dBrHXXRatio1 = BrHXXRatio - 1.0;
7914 dBrHXXRatio2 = 0.0;
7915 } else {
7916 throw std::runtime_error("STXS12_ggH_pTH60_200_Nj1 called with invalid argument for final state in fstate_i");
7917 }
7918
7919 //-- Production x Decay:
7920 if ((this->getModel()).isModelLinearized()){
7921 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7922 } else if((this->getModel()).isModelNPquadratic()){
7923 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7924 } else {
7925 return weight*(muProd)*(BrHXXRatio);
7926 }
7927
7928}
7929
7930
7931// -----------------------------------------------------------------------------
7932
7933STXS12_ggH_mjj0_350_pTH0_60_Nj2::STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7934: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7935{
7936 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7937 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with a class whose parent is not NPbase");
7938
7939}
7940
7942{
7943
7944
7945 //-- Production:
7946 double weight = 1.0; //If normalized to the SM
7947
7948 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)));
7949 double muProd1 = muProd -1.0;
7950 double muProd2 = 0.0;
7951
7952 //-- Decay:
7953 double BrHXXRatio = 1.0;
7954 double dBrHXXRatio1 = 0.0;
7955 double dBrHXXRatio2 = 0.0;
7956
7957
7958
7959 if (fstate==0){
7960 // Use for Cross-section [pb] with no Higgs-boson decay
7961 weight = (1.24); //Ref: CMS note HIG-21-018-PAS-V3
7962 } else if (fstate == 1){
7963 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7964 dBrHXXRatio1 = BrHXXRatio - 1.0;
7965 dBrHXXRatio2 = 0.0;
7966 } else if (fstate == 2){
7967 BrHXXRatio = (myNPbase->BrHgagaRatio());
7968 dBrHXXRatio1 = BrHXXRatio - 1.0;
7969 dBrHXXRatio2 = 0.0;
7970 } else if (fstate == 3){
7971 BrHXXRatio = (myNPbase->BrHbbRatio());
7972 dBrHXXRatio1 = BrHXXRatio - 1.0;
7973 dBrHXXRatio2 = 0.0;
7974 } else if (fstate == 4){
7975 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7976 dBrHXXRatio1 = BrHXXRatio - 1.0;
7977 dBrHXXRatio2 = 0.0;
7978 } else if (fstate == 5){
7979 BrHXXRatio = (myNPbase->BrHtautauRatio());
7980 dBrHXXRatio1 = BrHXXRatio - 1.0;
7981 dBrHXXRatio2 = 0.0;
7982 } else if (fstate == 6){
7983 BrHXXRatio = (myNPbase->BrHWWRatio());
7984 dBrHXXRatio1 = BrHXXRatio - 1.0;
7985 dBrHXXRatio2 = 0.0;
7986 } else if (fstate == 7){
7987 BrHXXRatio = (myNPbase->BrHZZRatio());
7988 dBrHXXRatio1 = BrHXXRatio - 1.0;
7989 dBrHXXRatio2 = 0.0;
7990 } else {
7991 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with invalid argument for final state in fstate_i");
7992 }
7993
7994
7995
7996 //-- Production x Decay:
7997 if ((this->getModel()).isModelLinearized()){
7998 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7999 } else if((this->getModel()).isModelNPquadratic()){
8000 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8001 } else {
8002 return weight*(muProd)*(BrHXXRatio);
8003 }
8004}
8005
8006// -----------------------------------------------------------------------------
8007
8008STXS12_ggH_mjj0_350_pTH60_120_Nj2::STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8009: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8010{
8011 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8012 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with a class whose parent is not NPbase");
8013
8014}
8015
8017{
8018
8019 //-- Production:
8020 double weight = 1.0; //If normalized to the SM
8021
8022
8024 double muProd1 = muProd -1.0;
8025 double muProd2 = 0.0;
8026
8027 //-- Decay:
8028 double BrHXXRatio = 1.0;
8029 double dBrHXXRatio1 = 0.0;
8030 double dBrHXXRatio2 = 0.0;
8031
8032
8033
8034 if (fstate==0){
8035 // Use for Cross-section [pb] with no Higgs-boson decay
8036 weight = (2.00); //Ref: CMS note HIG-21-018-PAS-V3
8037 } else if (fstate == 1){
8038 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8039 dBrHXXRatio1 = BrHXXRatio - 1.0;
8040 dBrHXXRatio2 = 0.0;
8041 } else if (fstate == 2){
8042 BrHXXRatio = (myNPbase->BrHgagaRatio());
8043 dBrHXXRatio1 = BrHXXRatio - 1.0;
8044 dBrHXXRatio2 = 0.0;
8045 } else if (fstate == 3){
8046 BrHXXRatio = (myNPbase->BrHbbRatio());
8047 dBrHXXRatio1 = BrHXXRatio - 1.0;
8048 dBrHXXRatio2 = 0.0;
8049 } else if (fstate == 4){
8050 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8051 dBrHXXRatio1 = BrHXXRatio - 1.0;
8052 dBrHXXRatio2 = 0.0;
8053 } else if (fstate == 5){
8054 BrHXXRatio = (myNPbase->BrHtautauRatio());
8055 dBrHXXRatio1 = BrHXXRatio - 1.0;
8056 dBrHXXRatio2 = 0.0;
8057 } else if (fstate == 6){
8058 BrHXXRatio = (myNPbase->BrHWWRatio());
8059 dBrHXXRatio1 = BrHXXRatio - 1.0;
8060 dBrHXXRatio2 = 0.0;
8061 } else if (fstate == 7){
8062 BrHXXRatio = (myNPbase->BrHZZRatio());
8063 dBrHXXRatio1 = BrHXXRatio - 1.0;
8064 dBrHXXRatio2 = 0.0;
8065 } else {
8066 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with invalid argument for final state in fstate_i");
8067 }
8068
8069 //-- Production x Decay:
8070 if ((this->getModel()).isModelLinearized()){
8071 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8072 } else if((this->getModel()).isModelNPquadratic()){
8073 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8074 } else {
8075 return weight*(muProd)*(BrHXXRatio);
8076 }
8077}
8078
8079
8080
8081
8082
8083// -----------------------------------------------------------------------------
8084
8085//VM:STXS2024;
8086STXS12_ggH_mjj0_350_pTH0_120_Nj2::STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8087: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8088{
8089 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8090 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with a class whose parent is not NPbase");
8091
8092}
8093
8095{
8096 //-- Production:
8097 double weight = 1.0; //If normalized to the SM
8098 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8099
8100 double muProd = ((1.24)*(myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) +
8102 /(1.24+2.00);
8103 double muProd1 = muProd -1.0;
8104 double muProd2 = 0.0;
8105
8106 //-- Decay:
8107 double BrHXXRatio = 1.0;
8108 double dBrHXXRatio1 = 0.0;
8109 double dBrHXXRatio2 = 0.0;
8110 if (fstate==0){
8111 // Use for Cross-section [pb] with no Higgs-boson decay
8112 weight = (2.9636); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8113 //This weight is a bit smaller than the sum of the weights considered for the two bins that
8114 //generate this bin when combined 1.24+2.00=3.24, This is because the values have been obtained
8115 //from different papers and they give slightly different predictions. However, the uncertainty
8116 //given by the ATLAS paper that combines the bins is of 0.6 pb for the SM prediction, above the
8117 //difference that we find with the other SM prediction so it is fine.
8118 } else if (fstate == 1){
8119 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8120 dBrHXXRatio1 = BrHXXRatio - 1.0;
8121 dBrHXXRatio2 = 0.0;
8122 } else if (fstate == 2){
8123 BrHXXRatio = (myNPbase->BrHgagaRatio());
8124 dBrHXXRatio1 = BrHXXRatio - 1.0;
8125 dBrHXXRatio2 = 0.0;
8126 } else if (fstate == 3){
8127 BrHXXRatio = (myNPbase->BrHbbRatio());
8128 dBrHXXRatio1 = BrHXXRatio - 1.0;
8129 dBrHXXRatio2 = 0.0;
8130 } else if (fstate == 4){
8131 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8132 dBrHXXRatio1 = BrHXXRatio - 1.0;
8133 dBrHXXRatio2 = 0.0;
8134 } else if (fstate == 5){
8135 BrHXXRatio = (myNPbase->BrHtautauRatio());
8136 dBrHXXRatio1 = BrHXXRatio - 1.0;
8137 dBrHXXRatio2 = 0.0;
8138 } else if (fstate == 6){
8139 BrHXXRatio = (myNPbase->BrHWWRatio());
8140 dBrHXXRatio1 = BrHXXRatio - 1.0;
8141 dBrHXXRatio2 = 0.0;
8142 } else if (fstate == 7){
8143 BrHXXRatio = (myNPbase->BrHZZRatio());
8144 dBrHXXRatio1 = BrHXXRatio - 1.0;
8145 dBrHXXRatio2 = 0.0;
8146 } else {
8147 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with invalid argument for final state in fstate_i");
8148 }
8149
8150 //-- Production x Decay:
8151 if ((this->getModel()).isModelLinearized()){
8152 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8153 } else if((this->getModel()).isModelNPquadratic()){
8154 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8155 } else {
8156 return weight*(muProd)*(BrHXXRatio);
8157 }
8158
8159}
8160
8161
8162
8163
8164// -----------------------------------------------------------------------------
8165
8166//AG:STXS2024
8167STXS12_ggH_mjj0_350_pTH120_200_Nj2::STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8168: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8169{
8170 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8171 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with a class whose parent is not NPbase");
8172
8173}
8174
8176{
8177 //-- Production:
8178 double weight = 1.0; //If normalized to the SM
8180 double muProd1 = muProd -1.0;
8181 double muProd2 = 0.0;
8182
8183 //-- Decay:
8184 double BrHXXRatio = 1.0;
8185 double dBrHXXRatio1 = 0.0;
8186 double dBrHXXRatio2 = 0.0;
8187 if (fstate==0){
8188 // Use for Cross-section [pb] with no Higgs-boson decay
8189 weight = 0.94325; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8190 } else if (fstate == 1){
8191 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8192 dBrHXXRatio1 = BrHXXRatio - 1.0;
8193 dBrHXXRatio2 = 0.0;
8194 } else if (fstate == 2){
8195 BrHXXRatio = (myNPbase->BrHgagaRatio());
8196 dBrHXXRatio1 = BrHXXRatio - 1.0;
8197 dBrHXXRatio2 = 0.0;
8198 } else if (fstate == 3){
8199 BrHXXRatio = (myNPbase->BrHbbRatio());
8200 dBrHXXRatio1 = BrHXXRatio - 1.0;
8201 dBrHXXRatio2 = 0.0;
8202 } else if (fstate == 4){
8203 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8204 dBrHXXRatio1 = BrHXXRatio - 1.0;
8205 dBrHXXRatio2 = 0.0;
8206 } else if (fstate == 5){
8207 BrHXXRatio = (myNPbase->BrHtautauRatio());
8208 dBrHXXRatio1 = BrHXXRatio - 1.0;
8209 dBrHXXRatio2 = 0.0;
8210 } else if (fstate == 6){
8211 BrHXXRatio = (myNPbase->BrHWWRatio());
8212 dBrHXXRatio1 = BrHXXRatio - 1.0;
8213 dBrHXXRatio2 = 0.0;
8214 } else if (fstate == 7){
8215 BrHXXRatio = (myNPbase->BrHZZRatio());
8216 dBrHXXRatio1 = BrHXXRatio - 1.0;
8217 dBrHXXRatio2 = 0.0;
8218 } else {
8219 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with invalid argument for final state in fstate_i");
8220 }
8221
8222 //-- Production x Decay:
8223 if ((this->getModel()).isModelLinearized()){
8224 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8225 } else if((this->getModel()).isModelNPquadratic()){
8226 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8227 } else {
8228 return weight*(muProd)*(BrHXXRatio);
8229 }
8230
8231}
8232
8233
8234
8235
8236//VM:STXS2024;
8237STXS12_ggH_mjj350_Inf_pTH0_200_Nj2::STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8238: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8239{
8240 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8241 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8242
8243}
8244
8246{
8247 //-- Production:
8248 double weight = 1.0; //If normalized to the SM
8249 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8250 //We should weight each xsection with the SM prediction. We need to check
8251 //this values, nevertheless, the difference between the two parametrisations
8252 //is extremely small (way beyond our current precision)
8255 /(2.);
8256 double muProd1 = muProd -1.0;
8257 double muProd2 = 0.0;
8258
8259 //-- Decay:
8260 double BrHXXRatio = 1.0;
8261 double dBrHXXRatio1 = 0.0;
8262 double dBrHXXRatio2 = 0.0;
8263 if (fstate==0){
8264 // Use for Cross-section [pb] with no Higgs-boson decay
8265 weight = (0.87751); //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8266 } else if (fstate == 1){
8267 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8268 dBrHXXRatio1 = BrHXXRatio - 1.0;
8269 dBrHXXRatio2 = 0.0;
8270 } else if (fstate == 2){
8271 BrHXXRatio = (myNPbase->BrHgagaRatio());
8272 dBrHXXRatio1 = BrHXXRatio - 1.0;
8273 dBrHXXRatio2 = 0.0;
8274 } else if (fstate == 3){
8275 BrHXXRatio = (myNPbase->BrHbbRatio());
8276 dBrHXXRatio1 = BrHXXRatio - 1.0;
8277 dBrHXXRatio2 = 0.0;
8278 } else if (fstate == 4){
8279 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8280 dBrHXXRatio1 = BrHXXRatio - 1.0;
8281 dBrHXXRatio2 = 0.0;
8282 } else if (fstate == 5){
8283 BrHXXRatio = (myNPbase->BrHtautauRatio());
8284 dBrHXXRatio1 = BrHXXRatio - 1.0;
8285 dBrHXXRatio2 = 0.0;
8286 } else if (fstate == 6){
8287 BrHXXRatio = (myNPbase->BrHWWRatio());
8288 dBrHXXRatio1 = BrHXXRatio - 1.0;
8289 dBrHXXRatio2 = 0.0;
8290 } else if (fstate == 7){
8291 BrHXXRatio = (myNPbase->BrHZZRatio());
8292 dBrHXXRatio1 = BrHXXRatio - 1.0;
8293 dBrHXXRatio2 = 0.0;
8294 } else {
8295 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8296 }
8297
8298 //-- Production x Decay:
8299 if ((this->getModel()).isModelLinearized()){
8300 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8301 } else if((this->getModel()).isModelNPquadratic()){
8302 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8303 } else {
8304 return weight*(muProd)*(BrHXXRatio);
8305 }
8306
8307}
8308
8309
8310// -----------------------------------------------------------------------------
8311
8313: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8314{
8315 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8316 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8317
8318}
8319
8321{
8322 double BrHXXRatio = 1.0;
8323 if (fstate == 1){
8324 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8325 } else if (fstate == 2){
8326 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8327 } else if (fstate == 3){
8328 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8329 } else if (fstate == 4){
8330 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8331 } else {
8332 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8333 }
8334
8335 if ((this->getModel()).isModelLinearized()) {
8336 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8337 } else {
8339 }
8340}
8341
8342// -----------------------------------------------------------------------------
8343
8345: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8346{
8347
8348 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8349 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8350
8351}
8352
8354{
8355 double BrHXXRatio = 1.0;
8356 if (fstate == 1){
8357 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8358 } else if (fstate == 2){
8359 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8360 } else if (fstate == 3){
8361 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8362 } else if (fstate == 4){
8363 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8364 } else {
8365 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8366 }
8367
8368 if ((this->getModel()).isModelLinearized()) {
8369 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8370 } else {
8372 }
8373}
8374
8375// -----------------------------------------------------------------------------
8376
8378: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8379{
8380 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8381 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8382
8383}
8384
8386{
8387 double BrHXXRatio = 1.0;
8388 if (fstate == 1){
8389 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8390 } else if (fstate == 2){
8391 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8392 } else if (fstate == 3){
8393 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8394 } else if (fstate == 4){
8395 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8396 } else {
8397 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8398 }
8399
8400 if ((this->getModel()).isModelLinearized()) {
8401 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8402 } else {
8404 }
8405}
8406
8407// -----------------------------------------------------------------------------
8408
8410: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8411{
8412 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8413 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8414
8415}
8416
8418{
8419 double BrHXXRatio = 1.0;
8420 if (fstate == 1){
8421 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8422 } else if (fstate == 2){
8423 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8424 } else if (fstate == 3){
8425 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8426 } else if (fstate == 4){
8427 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8428 } else {
8429 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8430 }
8431
8432 if ((this->getModel()).isModelLinearized()) {
8433 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8434 } else {
8436 }
8437}
8438
8439
8440
8441
8442
8443// -----------------------------------------------------------------------------
8444
8445//VM:STXS2024;
8446STXS12_ggH_pTH0_200_Nj2::STXS12_ggH_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8447: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8448{
8449 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8450 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8451
8452}
8453
8455{
8456
8457
8458
8459 //-- Production:
8460 double weight = 1.0; //If normalized to the SM
8461 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8462 //Ref: Also CMS note HIG-21-018-PAS-v3
8463 //VM: In the reference above we have the SM predictions for less bins. Angelica should have
8464 //the ones for Madgraph and we could use those. In any case the parametrisation is very stable
8465 //we give the same weight to the bins for which we don't have the SM prediction (for the moment)!
8466 //The possible error that we could be introducing here is way below our precision!
8467 double muProd = (
8472 )/(1.24+2.00+0.94321+0.87751);
8473 double muProd1 = muProd -1.0;
8474 double muProd2 = 0.0;
8475
8476 //-- Decay:
8477 double BrHXXRatio = 1.0;
8478 double dBrHXXRatio1 = 0.0;
8479 double dBrHXXRatio2 = 0.0;
8480 if (fstate==0){
8481 // Use for Cross-section [pb] with no Higgs-boson decay
8482 weight = (1.24+2.00+0.94321+0.87751); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8483 } else if (fstate == 1){
8484 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8485 dBrHXXRatio1 = BrHXXRatio - 1.0;
8486 dBrHXXRatio2 = 0.0;
8487 } else if (fstate == 2){
8488 BrHXXRatio = (myNPbase->BrHgagaRatio());
8489 dBrHXXRatio1 = BrHXXRatio - 1.0;
8490 dBrHXXRatio2 = 0.0;
8491 } else if (fstate == 3){
8492 BrHXXRatio = (myNPbase->BrHbbRatio());
8493 dBrHXXRatio1 = BrHXXRatio - 1.0;
8494 dBrHXXRatio2 = 0.0;
8495 } else if (fstate == 4){
8496 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8497 dBrHXXRatio1 = BrHXXRatio - 1.0;
8498 dBrHXXRatio2 = 0.0;
8499 } else if (fstate == 5){
8500 BrHXXRatio = (myNPbase->BrHtautauRatio());
8501 dBrHXXRatio1 = BrHXXRatio - 1.0;
8502 dBrHXXRatio2 = 0.0;
8503 } else if (fstate == 6){
8504 BrHXXRatio = (myNPbase->BrHWWRatio());
8505 dBrHXXRatio1 = BrHXXRatio - 1.0;
8506 dBrHXXRatio2 = 0.0;
8507 } else if (fstate == 7){
8508 BrHXXRatio = (myNPbase->BrHZZRatio());
8509 dBrHXXRatio1 = BrHXXRatio - 1.0;
8510 dBrHXXRatio2 = 0.0;
8511 } else {
8512 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8513 }
8514
8515 //-- Production x Decay:
8516 if ((this->getModel()).isModelLinearized()){
8517 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8518 } else if((this->getModel()).isModelNPquadratic()){
8519 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8520 } else {
8521 return weight*(muProd)*(BrHXXRatio);
8522 }
8523
8524}
8525
8526
8527
8528
8529
8530
8531
8532// -----------------------------------------------------------------------------
8533
8534
8535//VM:STXS2024;
8536STXS12_ggH_pTH200_Inf::STXS12_ggH_pTH200_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8537: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8538{
8539 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8540 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with a class whose parent is not NPbase");
8541
8542}
8543
8545{
8546 //-- Production:
8547 double weight = 1.0; //If normalized to the SM
8548 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8549 double muProd = ( 0.45825*(myNPbase->STXS12_ggH_pTH200_300(sqrt_s)) +
8552 /(0.45825 + 0.10632 + 0.017974);
8553 double muProd1 = muProd -1.0;
8554 double muProd2 = 0.0;
8555
8556 //-- Decay:
8557 double BrHXXRatio = 1.0;
8558 double dBrHXXRatio1 = 0.0;
8559 double dBrHXXRatio2 = 0.0;
8560 if (fstate==0){
8561 // Use for Cross-section [pb] with no Higgs-boson decay
8562 weight = (0.45825 + 0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8563 } else if (fstate == 1){
8564 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8565 dBrHXXRatio1 = BrHXXRatio - 1.0;
8566 dBrHXXRatio2 = 0.0;
8567 } else if (fstate == 2){
8568 BrHXXRatio = (myNPbase->BrHgagaRatio());
8569 dBrHXXRatio1 = BrHXXRatio - 1.0;
8570 dBrHXXRatio2 = 0.0;
8571 } else if (fstate == 3){
8572 BrHXXRatio = (myNPbase->BrHbbRatio());
8573 dBrHXXRatio1 = BrHXXRatio - 1.0;
8574 dBrHXXRatio2 = 0.0;
8575 } else if (fstate == 4){
8576 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8577 dBrHXXRatio1 = BrHXXRatio - 1.0;
8578 dBrHXXRatio2 = 0.0;
8579 } else if (fstate == 5){
8580 BrHXXRatio = (myNPbase->BrHtautauRatio());
8581 dBrHXXRatio1 = BrHXXRatio - 1.0;
8582 dBrHXXRatio2 = 0.0;
8583 } else if (fstate == 6){
8584 BrHXXRatio = (myNPbase->BrHWWRatio());
8585 dBrHXXRatio1 = BrHXXRatio - 1.0;
8586 dBrHXXRatio2 = 0.0;
8587 } else if (fstate == 7){
8588 BrHXXRatio = (myNPbase->BrHZZRatio());
8589 dBrHXXRatio1 = BrHXXRatio - 1.0;
8590 dBrHXXRatio2 = 0.0;
8591 } else {
8592 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8593 }
8594
8595 //-- Production x Decay:
8596 if ((this->getModel()).isModelLinearized()){
8597 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8598 } else if((this->getModel()).isModelNPquadratic()){
8599 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8600 } else {
8601 return weight*(muProd)*(BrHXXRatio);
8602 }
8603
8604}
8605
8606
8607
8608
8609// -----------------------------------------------------------------------------
8610
8611
8612//VM:STXS2024;
8613STXS12_ggH_pTH300_Inf::STXS12_ggH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8614: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8615{
8616 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8617 throw std::runtime_error("STXS12_ggH_pTH300_Inf called with a class whose parent is not NPbase");
8618
8619}
8620
8622{
8623 //-- Production:
8624 double weight = 1.0; //If normalized to the SM
8625 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8626 double muProd = (0.10632*(myNPbase->STXS12_ggH_pTH300_450(sqrt_s)) +
8628 /(0.10632 + 0.017974);
8629 double muProd1 = muProd -1.0;
8630 double muProd2 = 0.0;
8631
8632 //-- Decay:
8633 double BrHXXRatio = 1.0;
8634 double dBrHXXRatio1 = 0.0;
8635 double dBrHXXRatio2 = 0.0;
8636 if (fstate==0){
8637 // Use for Cross-section [pb] with no Higgs-boson decay
8638 weight = (0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8639 } else if (fstate == 1){
8640 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8641 dBrHXXRatio1 = BrHXXRatio - 1.0;
8642 dBrHXXRatio2 = 0.0;
8643 } else if (fstate == 2){
8644 BrHXXRatio = (myNPbase->BrHgagaRatio());
8645 dBrHXXRatio1 = BrHXXRatio - 1.0;
8646 dBrHXXRatio2 = 0.0;
8647 } else if (fstate == 3){
8648 BrHXXRatio = (myNPbase->BrHbbRatio());
8649 dBrHXXRatio1 = BrHXXRatio - 1.0;
8650 dBrHXXRatio2 = 0.0;
8651 } else if (fstate == 4){
8652 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8653 dBrHXXRatio1 = BrHXXRatio - 1.0;
8654 dBrHXXRatio2 = 0.0;
8655 } else if (fstate == 5){
8656 BrHXXRatio = (myNPbase->BrHtautauRatio());
8657 dBrHXXRatio1 = BrHXXRatio - 1.0;
8658 dBrHXXRatio2 = 0.0;
8659 } else if (fstate == 6){
8660 BrHXXRatio = (myNPbase->BrHWWRatio());
8661 dBrHXXRatio1 = BrHXXRatio - 1.0;
8662 dBrHXXRatio2 = 0.0;
8663 } else if (fstate == 7){
8664 BrHXXRatio = (myNPbase->BrHZZRatio());
8665 dBrHXXRatio1 = BrHXXRatio - 1.0;
8666 dBrHXXRatio2 = 0.0;
8667 } else {
8668 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8669 }
8670
8671 //-- Production x Decay:
8672 if ((this->getModel()).isModelLinearized()){
8673 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8674 } else if((this->getModel()).isModelNPquadratic()){
8675 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8676 } else {
8677 return weight*(muProd)*(BrHXXRatio);
8678 }
8679
8680}
8681
8682
8683// -----------------------------------------------------------------------------
8684
8685
8686//VM:STXS2024;
8687STXS12_ggH_pTH200_300::STXS12_ggH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8688: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8689{
8690 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8691 throw std::runtime_error("STXS12_ggH_pTH200_300 called with a class whose parent is not NPbase");
8692
8693}
8694
8696{
8697 //-- Production:
8698 double weight = 1.0; //If normalized to the SM
8699 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8700 double muProd = myNPbase->STXS12_ggH_pTH200_300(sqrt_s);
8701 double muProd1 = muProd -1.0;
8702 double muProd2 = 0.0;
8703
8704 //-- Decay:
8705 double BrHXXRatio = 1.0;
8706 double dBrHXXRatio1 = 0.0;
8707 double dBrHXXRatio2 = 0.0;
8708 if (fstate==0){
8709 // Use for Cross-section [pb] with no Higgs-boson decay
8710 weight = (0.45825 ); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8711 } else if (fstate == 1){
8712 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8713 dBrHXXRatio1 = BrHXXRatio - 1.0;
8714 dBrHXXRatio2 = 0.0;
8715 } else if (fstate == 2){
8716 BrHXXRatio = (myNPbase->BrHgagaRatio());
8717 dBrHXXRatio1 = BrHXXRatio - 1.0;
8718 dBrHXXRatio2 = 0.0;
8719 } else if (fstate == 3){
8720 BrHXXRatio = (myNPbase->BrHbbRatio());
8721 dBrHXXRatio1 = BrHXXRatio - 1.0;
8722 dBrHXXRatio2 = 0.0;
8723 } else if (fstate == 4){
8724 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8725 dBrHXXRatio1 = BrHXXRatio - 1.0;
8726 dBrHXXRatio2 = 0.0;
8727 } else if (fstate == 5){
8728 BrHXXRatio = (myNPbase->BrHtautauRatio());
8729 dBrHXXRatio1 = BrHXXRatio - 1.0;
8730 dBrHXXRatio2 = 0.0;
8731 } else if (fstate == 6){
8732 BrHXXRatio = (myNPbase->BrHWWRatio());
8733 dBrHXXRatio1 = BrHXXRatio - 1.0;
8734 dBrHXXRatio2 = 0.0;
8735 } else if (fstate == 7){
8736 BrHXXRatio = (myNPbase->BrHZZRatio());
8737 dBrHXXRatio1 = BrHXXRatio - 1.0;
8738 dBrHXXRatio2 = 0.0;
8739 } else {
8740 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8741 }
8742
8743 //-- Production x Decay:
8744 if ((this->getModel()).isModelLinearized()){
8745 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8746 } else if((this->getModel()).isModelNPquadratic()){
8747 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8748 } else {
8749 return weight*(muProd)*(BrHXXRatio);
8750 }
8751
8752}
8753
8754
8755
8756// -----------------------------------------------------------------------------
8757
8758
8759//VM:STXS2024;
8760STXS12_ggH_pTH300_450::STXS12_ggH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8761: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8762{
8763 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8764 throw std::runtime_error("STXS12_ggH_pTH300_450 called with a class whose parent is not NPbase");
8765
8766}
8767
8769{
8770 //-- Production:
8771 double weight = 1.0; //If normalized to the SM
8772 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8773 double muProd = myNPbase->STXS12_ggH_pTH300_450(sqrt_s);
8774 double muProd1 = muProd -1.0;
8775 double muProd2 = 0.0;
8776
8777 //-- Decay:
8778 double BrHXXRatio = 1.0;
8779 double dBrHXXRatio1 = 0.0;
8780 double dBrHXXRatio2 = 0.0;
8781 if (fstate==0){
8782 // Use for Cross-section [pb] with no Higgs-boson decay
8783 weight = 0.10632; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8784 } else if (fstate == 1){
8785 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8786 dBrHXXRatio1 = BrHXXRatio - 1.0;
8787 dBrHXXRatio2 = 0.0;
8788 } else if (fstate == 2){
8789 BrHXXRatio = (myNPbase->BrHgagaRatio());
8790 dBrHXXRatio1 = BrHXXRatio - 1.0;
8791 dBrHXXRatio2 = 0.0;
8792 } else if (fstate == 3){
8793 BrHXXRatio = (myNPbase->BrHbbRatio());
8794 dBrHXXRatio1 = BrHXXRatio - 1.0;
8795 dBrHXXRatio2 = 0.0;
8796 } else if (fstate == 4){
8797 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8798 dBrHXXRatio1 = BrHXXRatio - 1.0;
8799 dBrHXXRatio2 = 0.0;
8800 } else if (fstate == 5){
8801 BrHXXRatio = (myNPbase->BrHtautauRatio());
8802 dBrHXXRatio1 = BrHXXRatio - 1.0;
8803 dBrHXXRatio2 = 0.0;
8804 } else if (fstate == 6){
8805 BrHXXRatio = (myNPbase->BrHWWRatio());
8806 dBrHXXRatio1 = BrHXXRatio - 1.0;
8807 dBrHXXRatio2 = 0.0;
8808 } else if (fstate == 7){
8809 BrHXXRatio = (myNPbase->BrHZZRatio());
8810 dBrHXXRatio1 = BrHXXRatio - 1.0;
8811 dBrHXXRatio2 = 0.0;
8812 } else {
8813 throw std::runtime_error("STXS12_ggH_pTH300_450 called with invalid argument for final state in fstate_i");
8814 }
8815
8816 //-- Production x Decay:
8817 if ((this->getModel()).isModelLinearized()){
8818 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8819 } else if((this->getModel()).isModelNPquadratic()){
8820 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8821 } else {
8822 return weight*(muProd)*(BrHXXRatio);
8823 }
8824
8825}
8826
8827
8828
8829
8830// -----------------------------------------------------------------------------
8831
8832
8833//VM:STXS2024;
8834STXS12_ggH_pTH450_650::STXS12_ggH_pTH450_650(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8835: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8836{
8837 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8838 throw std::runtime_error("STXS12_ggH_pTH450_650 called with a class whose parent is not NPbase");
8839
8840}
8841
8843{
8844 //-- Production:
8845 double weight = 1.0; //If normalized to the SM
8846 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8847 double muProd = myNPbase->STXS12_ggH_pTH450_650(sqrt_s);
8848 double muProd1 = muProd -1.0;
8849 double muProd2 = 0.0;
8850
8851 //-- Decay:
8852 double BrHXXRatio = 1.0;
8853 double dBrHXXRatio1 = 0.0;
8854 double dBrHXXRatio2 = 0.0;
8855 if (fstate==0){
8856 // Use for Cross-section [pb] with no Higgs-boson decay
8857 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8858 } else if (fstate == 1){
8859 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8860 dBrHXXRatio1 = BrHXXRatio - 1.0;
8861 dBrHXXRatio2 = 0.0;
8862 } else if (fstate == 2){
8863 BrHXXRatio = (myNPbase->BrHgagaRatio());
8864 dBrHXXRatio1 = BrHXXRatio - 1.0;
8865 dBrHXXRatio2 = 0.0;
8866 } else if (fstate == 3){
8867 BrHXXRatio = (myNPbase->BrHbbRatio());
8868 dBrHXXRatio1 = BrHXXRatio - 1.0;
8869 dBrHXXRatio2 = 0.0;
8870 } else if (fstate == 4){
8871 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8872 dBrHXXRatio1 = BrHXXRatio - 1.0;
8873 dBrHXXRatio2 = 0.0;
8874 } else if (fstate == 5){
8875 BrHXXRatio = (myNPbase->BrHtautauRatio());
8876 dBrHXXRatio1 = BrHXXRatio - 1.0;
8877 dBrHXXRatio2 = 0.0;
8878 } else if (fstate == 6){
8879 BrHXXRatio = (myNPbase->BrHWWRatio());
8880 dBrHXXRatio1 = BrHXXRatio - 1.0;
8881 dBrHXXRatio2 = 0.0;
8882 } else if (fstate == 7){
8883 BrHXXRatio = (myNPbase->BrHZZRatio());
8884 dBrHXXRatio1 = BrHXXRatio - 1.0;
8885 dBrHXXRatio2 = 0.0;
8886 } else {
8887 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8888 }
8889
8890 //-- Production x Decay:
8891 if ((this->getModel()).isModelLinearized()){
8892 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8893 } else if((this->getModel()).isModelNPquadratic()){
8894 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8895 } else {
8896 return weight*(muProd)*(BrHXXRatio);
8897 }
8898
8899}
8900
8901
8902
8903// -----------------------------------------------------------------------------
8904
8905
8906//VM:STXS2024;
8907STXS12_ggH_pTH650_Inf::STXS12_ggH_pTH650_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8908: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8909{
8910 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8911 throw std::runtime_error("STXS12_ggH_pTH650_Inf called with a class whose parent is not NPbase");
8912
8913}
8914
8916{
8917 //-- Production:
8918 double weight = 1.0; //If normalized to the SM
8919 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8920 double muProd = myNPbase->STXS12_ggH_pTH650_Inf(sqrt_s);
8921 double muProd1 = muProd -1.0;
8922 double muProd2 = 0.0;
8923
8924 //-- Decay:
8925 double BrHXXRatio = 1.0;
8926 double dBrHXXRatio1 = 0.0;
8927 double dBrHXXRatio2 = 0.0;
8928 if (fstate==0){
8929 // Use for Cross-section [pb] with no Higgs-boson decay
8930 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8931 } else if (fstate == 1){
8932 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8933 dBrHXXRatio1 = BrHXXRatio - 1.0;
8934 dBrHXXRatio2 = 0.0;
8935 } else if (fstate == 2){
8936 BrHXXRatio = (myNPbase->BrHgagaRatio());
8937 dBrHXXRatio1 = BrHXXRatio - 1.0;
8938 dBrHXXRatio2 = 0.0;
8939 } else if (fstate == 3){
8940 BrHXXRatio = (myNPbase->BrHbbRatio());
8941 dBrHXXRatio1 = BrHXXRatio - 1.0;
8942 dBrHXXRatio2 = 0.0;
8943 } else if (fstate == 4){
8944 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8945 dBrHXXRatio1 = BrHXXRatio - 1.0;
8946 dBrHXXRatio2 = 0.0;
8947 } else if (fstate == 5){
8948 BrHXXRatio = (myNPbase->BrHtautauRatio());
8949 dBrHXXRatio1 = BrHXXRatio - 1.0;
8950 dBrHXXRatio2 = 0.0;
8951 } else if (fstate == 6){
8952 BrHXXRatio = (myNPbase->BrHWWRatio());
8953 dBrHXXRatio1 = BrHXXRatio - 1.0;
8954 dBrHXXRatio2 = 0.0;
8955 } else if (fstate == 7){
8956 BrHXXRatio = (myNPbase->BrHZZRatio());
8957 dBrHXXRatio1 = BrHXXRatio - 1.0;
8958 dBrHXXRatio2 = 0.0;
8959 } else {
8960 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8961 }
8962
8963 //-- Production x Decay:
8964 if ((this->getModel()).isModelLinearized()){
8965 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8966 } else if((this->getModel()).isModelNPquadratic()){
8967 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8968 } else {
8969 return weight*(muProd)*(BrHXXRatio);
8970 }
8971
8972}
8973
8974
8975
8976// -----------------------------------------------------------------------------
8977
8978
8979//VM:STXS2024;
8980STXS12_ggH_pTH450_Inf::STXS12_ggH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8981: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8982{
8983 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8984 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with a class whose parent is not NPbase");
8985
8986}
8987
8989{
8990 //-- Production:
8991 double weight = 1.0; //If normalized to the SM
8992 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8993 double muProd = myNPbase->STXS12_ggH_pTH450_Inf(sqrt_s);
8994 double muProd1 = muProd -1.0;
8995 double muProd2 = 0.0;
8996
8997 //-- Decay:
8998 double BrHXXRatio = 1.0;
8999 double dBrHXXRatio1 = 0.0;
9000 double dBrHXXRatio2 = 0.0;
9001 if (fstate==0){
9002 // Use for Cross-section [pb] with no Higgs-boson decay
9003 weight = 0.017974; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9004 } else if (fstate == 1){
9005 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9006 dBrHXXRatio1 = BrHXXRatio - 1.0;
9007 dBrHXXRatio2 = 0.0;
9008 } else if (fstate == 2){
9009 BrHXXRatio = (myNPbase->BrHgagaRatio());
9010 dBrHXXRatio1 = BrHXXRatio - 1.0;
9011 dBrHXXRatio2 = 0.0;
9012 } else if (fstate == 3){
9013 BrHXXRatio = (myNPbase->BrHbbRatio());
9014 dBrHXXRatio1 = BrHXXRatio - 1.0;
9015 dBrHXXRatio2 = 0.0;
9016 } else if (fstate == 4){
9017 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9018 dBrHXXRatio1 = BrHXXRatio - 1.0;
9019 dBrHXXRatio2 = 0.0;
9020 } else if (fstate == 5){
9021 BrHXXRatio = (myNPbase->BrHtautauRatio());
9022 dBrHXXRatio1 = BrHXXRatio - 1.0;
9023 dBrHXXRatio2 = 0.0;
9024 } else if (fstate == 6){
9025 BrHXXRatio = (myNPbase->BrHWWRatio());
9026 dBrHXXRatio1 = BrHXXRatio - 1.0;
9027 dBrHXXRatio2 = 0.0;
9028 } else if (fstate == 7){
9029 BrHXXRatio = (myNPbase->BrHZZRatio());
9030 dBrHXXRatio1 = BrHXXRatio - 1.0;
9031 dBrHXXRatio2 = 0.0;
9032 } else {
9033 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
9034 }
9035
9036 //-- Production x Decay:
9037 if ((this->getModel()).isModelLinearized()){
9038 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9039 } else if((this->getModel()).isModelNPquadratic()){
9040 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9041 } else {
9042 return weight*(muProd)*(BrHXXRatio);
9043 }
9044
9045}
9046
9047
9048// -----------------------------------------------------------------------------
9049
9050STXS12_ggHll_pTV0_75::STXS12_ggHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9051: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9052{
9053 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9054 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with a class whose parent is not NPbase");
9055
9056}
9057
9059{
9060 double BrHXXRatio = 1.0;
9061 if (fstate == 1){
9062 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9063 } else if (fstate == 2){
9064 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9065 } else if (fstate == 3){
9066 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9067 } else if (fstate == 4){
9068 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9069 } else {
9070 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with invalid argument for final state in fstate_i");
9071 }
9072
9073 if ((this->getModel()).isModelLinearized()) {
9074 return ((myNPbase->STXS12_ggHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
9075 } else {
9076 return (myNPbase->STXS12_ggHll_pTV0_75(sqrt_s))*(BrHXXRatio);
9077 }
9078}
9079
9080// -----------------------------------------------------------------------------
9081
9082STXS12_ggHll_pTV75_150::STXS12_ggHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9083: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9084{
9085 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9086 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with a class whose parent is not NPbase");
9087
9088}
9089
9091{
9092 double BrHXXRatio = 1.0;
9093 if (fstate == 1){
9094 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9095 } else if (fstate == 2){
9096 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9097 } else if (fstate == 3){
9098 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9099 } else if (fstate == 4){
9100 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9101 } else {
9102 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with invalid argument for final state in fstate_i");
9103 }
9104
9105 if ((this->getModel()).isModelLinearized()) {
9106 return ((myNPbase->STXS12_ggHll_pTV75_150(sqrt_s)) + (BrHXXRatio) - 1.0);
9107 } else {
9108 return (myNPbase->STXS12_ggHll_pTV75_150(sqrt_s))*(BrHXXRatio);
9109 }
9110}
9111
9112// -----------------------------------------------------------------------------
9113
9114STXS12_ggHll_pTV150_250_Nj0::STXS12_ggHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9115: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9116{
9117 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9118 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
9119
9120}
9121
9123{
9124 double BrHXXRatio = 1.0;
9125 if (fstate == 1){
9126 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9127 } else if (fstate == 2){
9128 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9129 } else if (fstate == 3){
9130 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9131 } else if (fstate == 4){
9132 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9133 } else {
9134 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
9135 }
9136
9137 if ((this->getModel()).isModelLinearized()) {
9138 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
9139 } else {
9140 return (myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s))*(BrHXXRatio);
9141 }
9142}
9143
9144// -----------------------------------------------------------------------------
9145
9146STXS12_ggHll_pTV150_250_Nj1::STXS12_ggHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9147: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9148{
9149 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9150 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
9151
9152}
9153
9155{
9156 double BrHXXRatio = 1.0;
9157 if (fstate == 1){
9158 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9159 } else if (fstate == 2){
9160 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9161 } else if (fstate == 3){
9162 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9163 } else if (fstate == 4){
9164 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9165 } else {
9166 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
9167 }
9168
9169 if ((this->getModel()).isModelLinearized()) {
9170 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
9171 } else {
9172 return (myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
9173 }
9174}
9175
9176// -----------------------------------------------------------------------------
9177
9178STXS12_ggHll_pTV250_Inf::STXS12_ggHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9179: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9180{
9181 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9182 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with a class whose parent is not NPbase");
9183
9184}
9185
9187{
9188 double BrHXXRatio = 1.0;
9189 if (fstate == 1){
9190 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9191 } else if (fstate == 2){
9192 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9193 } else if (fstate == 3){
9194 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9195 } else if (fstate == 4){
9196 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9197 } else {
9198 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with invalid argument for final state in fstate_i");
9199 }
9200
9201 if ((this->getModel()).isModelLinearized()) {
9202 return ((myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
9203 } else {
9204 return (myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
9205 }
9206}
9207
9208// -----------------------------------------------------------------------------
9209
9210STXS12_qqHqq_Nj0::STXS12_qqHqq_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9211: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9212{
9213 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9214 throw std::runtime_error("STXS12_qqHqq_Nj0 called with a class whose parent is not NPbase");
9215
9216}
9217
9219{
9220 double BrHXXRatio = 1.0;
9221 if (fstate == 1){
9222 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9223 } else if (fstate == 2){
9224 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9225 } else if (fstate == 3){
9226 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9227 } else if (fstate == 4){
9228 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9229 } else {
9230 throw std::runtime_error("STXS12_qqHqq_Nj called with invalid argument for final state in fstate_i");
9231 }
9232
9233 if ((this->getModel()).isModelLinearized()) {
9234 return ((myNPbase->STXS12_qqHqq_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
9235 } else {
9236 return (myNPbase->STXS12_qqHqq_Nj0(sqrt_s))*(BrHXXRatio);
9237 }
9238}
9239
9240// -----------------------------------------------------------------------------
9241
9242STXS12_qqHqq_Nj1::STXS12_qqHqq_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9243: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9244{
9245 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9246 throw std::runtime_error("STXS12_qqHqq_Nj1 called with a class whose parent is not NPbase");
9247
9248}
9249
9251{
9252 double BrHXXRatio = 1.0;
9253 if (fstate == 1){
9254 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9255 } else if (fstate == 2){
9256 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9257 } else if (fstate == 3){
9258 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9259 } else if (fstate == 4){
9260 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9261 } else {
9262 throw std::runtime_error("STXS12_qqHqq_Nj1 called with invalid argument for final state in fstate_i");
9263 }
9264
9265 if ((this->getModel()).isModelLinearized()) {
9266 return ((myNPbase->STXS12_qqHqq_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
9267 } else {
9268 return (myNPbase->STXS12_qqHqq_Nj1(sqrt_s))*(BrHXXRatio);
9269 }
9270}
9271
9272// -----------------------------------------------------------------------------
9273
9274STXS12_qqHqq_mjj0_60_Nj2::STXS12_qqHqq_mjj0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9275: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9276{
9277 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9278 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with a class whose parent is not NPbase");
9279
9280}
9281
9283{
9284 double BrHXXRatio = 1.0;
9285 if (fstate == 1){
9286 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9287 } else if (fstate == 2){
9288 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9289 } else if (fstate == 3){
9290 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9291 } else if (fstate == 4){
9292 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9293 } else {
9294 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with invalid argument for final state in fstate_i");
9295 }
9296
9297 if ((this->getModel()).isModelLinearized()) {
9298 return ((myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9299 } else {
9300 return (myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s))*(BrHXXRatio);
9301 }
9302}
9303
9304
9305
9306// -----------------------------------------------------------------------------
9307
9308
9309//VM:STXS2024;
9310STXS12_qqHqq_VH_veto_Nj01::STXS12_qqHqq_VH_veto_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9311: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9312{
9313 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9314 throw std::runtime_error("STXS12_qqHqq_VH_veto_Nj01 called with a class whose parent is not NPbase");
9315
9316}
9317
9319{
9320 //-- Production:
9321 double weight = 1.0; //If normalized to the SM
9322 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9323 double muProd = myNPbase->STXS12_qqHqq_VH_veto_Nj01(sqrt_s);
9324 double muProd1 = muProd -1.0;
9325 double muProd2 = 0.0;
9326
9327 //-- Decay:
9328 double BrHXXRatio = 1.0;
9329 double dBrHXXRatio1 = 0.0;
9330 double dBrHXXRatio2 = 0.0;
9331 if (fstate==0){
9332 // Use for Cross-section [pb] with no Higgs-boson decay
9333 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9334 } else if (fstate == 1){
9335 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9336 dBrHXXRatio1 = BrHXXRatio - 1.0;
9337 dBrHXXRatio2 = 0.0;
9338 } else if (fstate == 2){
9339 BrHXXRatio = (myNPbase->BrHgagaRatio());
9340 dBrHXXRatio1 = BrHXXRatio - 1.0;
9341 dBrHXXRatio2 = 0.0;
9342 } else if (fstate == 3){
9343 BrHXXRatio = (myNPbase->BrHbbRatio());
9344 dBrHXXRatio1 = BrHXXRatio - 1.0;
9345 dBrHXXRatio2 = 0.0;
9346 } else if (fstate == 4){
9347 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9348 dBrHXXRatio1 = BrHXXRatio - 1.0;
9349 dBrHXXRatio2 = 0.0;
9350 } else if (fstate == 5){
9351 BrHXXRatio = (myNPbase->BrHtautauRatio());
9352 dBrHXXRatio1 = BrHXXRatio - 1.0;
9353 dBrHXXRatio2 = 0.0;
9354 } else if (fstate == 6){
9355 BrHXXRatio = (myNPbase->BrHWWRatio());
9356 dBrHXXRatio1 = BrHXXRatio - 1.0;
9357 dBrHXXRatio2 = 0.0;
9358 } else if (fstate == 7){
9359 BrHXXRatio = (myNPbase->BrHZZRatio());
9360 dBrHXXRatio1 = BrHXXRatio - 1.0;
9361 dBrHXXRatio2 = 0.0;
9362 } else {
9363 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9364 }
9365
9366 //-- Production x Decay:
9367 if ((this->getModel()).isModelLinearized()){
9368 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9369 } else if((this->getModel()).isModelNPquadratic()){
9370 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9371 } else {
9372 return weight*(muProd)*(BrHXXRatio);
9373 }
9374
9375}
9376
9377
9378
9379
9380
9381
9382// -----------------------------------------------------------------------------
9383
9384//AG:STXS2024
9385STXS12_qqHqq_mjj60_120_Nj2::STXS12_qqHqq_mjj60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9386: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9387{
9388 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9389 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with a class whose parent is not NPbase");
9390
9391}
9392
9394{
9395 //-- Production:
9396 double weight = 1.0; //If normalized to the SM
9397 double muProd = myNPbase->STXS12_qqHqq_mjj60_120_Nj2(sqrt_s);
9398 double muProd1 = muProd -1.0;
9399 double muProd2 = 0.0;
9400
9401 //-- Decay:
9402 double BrHXXRatio = 1.0;
9403 double dBrHXXRatio1 = 0.0;
9404 double dBrHXXRatio2 = 0.0;
9405 if (fstate==0){
9406 // Use for Cross-section [pb] with no Higgs-boson decay
9407 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9408 } else if (fstate == 1){
9409 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9410 dBrHXXRatio1 = BrHXXRatio - 1.0;
9411 dBrHXXRatio2 = 0.0;
9412 } else if (fstate == 2){
9413 BrHXXRatio = (myNPbase->BrHgagaRatio());
9414 dBrHXXRatio1 = BrHXXRatio - 1.0;
9415 dBrHXXRatio2 = 0.0;
9416 } else if (fstate == 3){
9417 BrHXXRatio = (myNPbase->BrHbbRatio());
9418 dBrHXXRatio1 = BrHXXRatio - 1.0;
9419 dBrHXXRatio2 = 0.0;
9420 } else if (fstate == 4){
9421 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9422 dBrHXXRatio1 = BrHXXRatio - 1.0;
9423 dBrHXXRatio2 = 0.0;
9424 } else if (fstate == 5){
9425 BrHXXRatio = (myNPbase->BrHtautauRatio());
9426 dBrHXXRatio1 = BrHXXRatio - 1.0;
9427 dBrHXXRatio2 = 0.0;
9428 } else if (fstate == 6){
9429 BrHXXRatio = (myNPbase->BrHWWRatio());
9430 dBrHXXRatio1 = BrHXXRatio - 1.0;
9431 dBrHXXRatio2 = 0.0;
9432 } else if (fstate == 7){
9433 BrHXXRatio = (myNPbase->BrHZZRatio());
9434 dBrHXXRatio1 = BrHXXRatio - 1.0;
9435 dBrHXXRatio2 = 0.0;
9436 } else {
9437 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with invalid argument for final state in fstate_i");
9438 }
9439
9440 //-- Production x Decay:
9441 if ((this->getModel()).isModelLinearized()){
9442 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9443 } else if((this->getModel()).isModelNPquadratic()){
9444 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9445 } else {
9446 return weight*(muProd)*(BrHXXRatio);
9447 }
9448}
9449
9450// -----------------------------------------------------------------------------
9451
9452STXS12_qqHqq_mjj120_350_Nj2::STXS12_qqHqq_mjj120_350_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9453: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9454{
9455 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9456 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with a class whose parent is not NPbase");
9457
9458}
9459
9461{
9462 double BrHXXRatio = 1.0;
9463 if (fstate == 1){
9464 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9465 } else if (fstate == 2){
9466 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9467 } else if (fstate == 3){
9468 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9469 } else if (fstate == 4){
9470 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9471 } else {
9472 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with invalid argument for final state in fstate_i");
9473 }
9474
9475 if ((this->getModel()).isModelLinearized()) {
9476 return ((myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9477 } else {
9478 return (myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s))*(BrHXXRatio);
9479 }
9480}
9481
9482// -----------------------------------------------------------------------------
9483
9484//AG:STXS2024
9486: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9487{
9488 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9489 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9490
9491}
9492
9494{
9495 //-- Production:
9496 double weight = 1.0; //If normalized to the SM
9498 double muProd1 = muProd -1.0;
9499 double muProd2 = 0.0;
9500
9501 //-- Decay:
9502 double BrHXXRatio = 1.0;
9503 double dBrHXXRatio1 = 0.0;
9504 double dBrHXXRatio2 = 0.0;
9505 if (fstate==0){
9506 // Use for Cross-section [pb] with no Higgs-boson decay
9507 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9508 } else if (fstate == 1){
9509 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9510 dBrHXXRatio1 = BrHXXRatio - 1.0;
9511 dBrHXXRatio2 = 0.0;
9512 } else if (fstate == 2){
9513 BrHXXRatio = (myNPbase->BrHgagaRatio());
9514 dBrHXXRatio1 = BrHXXRatio - 1.0;
9515 dBrHXXRatio2 = 0.0;
9516 } else if (fstate == 3){
9517 BrHXXRatio = (myNPbase->BrHbbRatio());
9518 dBrHXXRatio1 = BrHXXRatio - 1.0;
9519 dBrHXXRatio2 = 0.0;
9520 } else if (fstate == 4){
9521 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9522 dBrHXXRatio1 = BrHXXRatio - 1.0;
9523 dBrHXXRatio2 = 0.0;
9524 } else if (fstate == 5){
9525 BrHXXRatio = (myNPbase->BrHtautauRatio());
9526 dBrHXXRatio1 = BrHXXRatio - 1.0;
9527 dBrHXXRatio2 = 0.0;
9528 } else if (fstate == 6){
9529 BrHXXRatio = (myNPbase->BrHWWRatio());
9530 dBrHXXRatio1 = BrHXXRatio - 1.0;
9531 dBrHXXRatio2 = 0.0;
9532 } else if (fstate == 7){
9533 BrHXXRatio = (myNPbase->BrHZZRatio());
9534 dBrHXXRatio1 = BrHXXRatio - 1.0;
9535 dBrHXXRatio2 = 0.0;
9536 } else {
9537 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9538 }
9539
9540
9541 //-- Production x Decay:
9542 if ((this->getModel()).isModelLinearized()){
9543 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9544 } else if((this->getModel()).isModelNPquadratic()){
9545 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9546 } else {
9547 return weight*(muProd)*(BrHXXRatio);
9548 }
9549
9550}
9551
9552// -----------------------------------------------------------------------------
9553
9554
9555
9556
9557
9558
9559
9561: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9562{
9563 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9564 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9565
9566}
9567
9569{
9570
9571 //-- Production:
9572 double weight = 1.0; //If normalized to the SM
9574 double muProd1 = muProd -1.0;
9575 double muProd2 = 0.0;
9576
9577 //-- Decay:
9578 double BrHXXRatio = 1.0;
9579 double dBrHXXRatio1 = 0.0;
9580 double dBrHXXRatio2 = 0.0;
9581 if (fstate==0){
9582 // Use for Cross-section [pb] with no Higgs-boson decay
9583 weight = 0.3948; //Ref: CMS-HIG-21-018-PAS-v3
9584 } else if (fstate == 1){
9585 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9586 dBrHXXRatio1 = BrHXXRatio - 1.0;
9587 dBrHXXRatio2 = 0.0;
9588 } else if (fstate == 2){
9589 BrHXXRatio = (myNPbase->BrHgagaRatio());
9590 dBrHXXRatio1 = BrHXXRatio - 1.0;
9591 dBrHXXRatio2 = 0.0;
9592 } else if (fstate == 3){
9593 BrHXXRatio = (myNPbase->BrHbbRatio());
9594 dBrHXXRatio1 = BrHXXRatio - 1.0;
9595 dBrHXXRatio2 = 0.0;
9596 } else if (fstate == 4){
9597 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9598 dBrHXXRatio1 = BrHXXRatio - 1.0;
9599 dBrHXXRatio2 = 0.0;
9600 } else if (fstate == 5){
9601 BrHXXRatio = (myNPbase->BrHtautauRatio());
9602 dBrHXXRatio1 = BrHXXRatio - 1.0;
9603 dBrHXXRatio2 = 0.0;
9604 } else if (fstate == 6){
9605 BrHXXRatio = (myNPbase->BrHWWRatio());
9606 dBrHXXRatio1 = BrHXXRatio - 1.0;
9607 dBrHXXRatio2 = 0.0;
9608 } else if (fstate == 7){
9609 BrHXXRatio = (myNPbase->BrHZZRatio());
9610 dBrHXXRatio1 = BrHXXRatio - 1.0;
9611 dBrHXXRatio2 = 0.0;
9612 } else {
9613 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9614 }
9615
9616 //-- Production x Decay:
9617 if ((this->getModel()).isModelLinearized()){
9618 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9619 } else if((this->getModel()).isModelNPquadratic()){
9620 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9621 } else {
9622 return weight*(muProd)*(BrHXXRatio);
9623 }
9624
9625
9626
9627
9628
9629
9630
9631}
9632
9633// -----------------------------------------------------------------------------
9634
9636: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9637{
9638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9639 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9640
9641}
9642
9644{
9645
9646 //-- Production:
9647 double weight = 1.0; //If normalized to the SM
9649 double muProd1 = muProd -1.0;
9650 double muProd2 = 0.0;
9651
9652 //-- Decay:
9653 double BrHXXRatio = 1.0;
9654 double dBrHXXRatio1 = 0.0;
9655 double dBrHXXRatio2 = 0.0;
9656 if (fstate==0){
9657 // Use for Cross-section [pb] with no Higgs-boson decay
9658 weight = 0.175166; //Ref: CMS-HIG-21-018-PAS-v3
9659 } else if (fstate == 1){
9660 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9661 dBrHXXRatio1 = BrHXXRatio - 1.0;
9662 dBrHXXRatio2 = 0.0;
9663 } else if (fstate == 2){
9664 BrHXXRatio = (myNPbase->BrHgagaRatio());
9665 dBrHXXRatio1 = BrHXXRatio - 1.0;
9666 dBrHXXRatio2 = 0.0;
9667 } else if (fstate == 3){
9668 BrHXXRatio = (myNPbase->BrHbbRatio());
9669 dBrHXXRatio1 = BrHXXRatio - 1.0;
9670 dBrHXXRatio2 = 0.0;
9671 } else if (fstate == 4){
9672 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9673 dBrHXXRatio1 = BrHXXRatio - 1.0;
9674 dBrHXXRatio2 = 0.0;
9675 } else if (fstate == 5){
9676 BrHXXRatio = (myNPbase->BrHtautauRatio());
9677 dBrHXXRatio1 = BrHXXRatio - 1.0;
9678 dBrHXXRatio2 = 0.0;
9679 } else if (fstate == 6){
9680 BrHXXRatio = (myNPbase->BrHWWRatio());
9681 dBrHXXRatio1 = BrHXXRatio - 1.0;
9682 dBrHXXRatio2 = 0.0;
9683 } else if (fstate == 7){
9684 BrHXXRatio = (myNPbase->BrHZZRatio());
9685 dBrHXXRatio1 = BrHXXRatio - 1.0;
9686 dBrHXXRatio2 = 0.0;
9687 } else {
9688 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9689 }
9690
9691 //-- Production x Decay:
9692 if ((this->getModel()).isModelLinearized()){
9693 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9694 } else if((this->getModel()).isModelNPquadratic()){
9695 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9696 } else {
9697 return weight*(muProd)*(BrHXXRatio);
9698 }
9699
9700
9701
9702}
9703
9704// -----------------------------------------------------------------------------
9705
9707: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9708{
9709 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9710 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9711
9712}
9713
9715{
9716
9717
9718
9719 //-- Production:
9720 double weight = 1.0; //If normalized to the SM
9722 double muProd1 = muProd -1.0;
9723 double muProd2 = 0.0;
9724
9725 //-- Decay:
9726 double BrHXXRatio = 1.0;
9727 double dBrHXXRatio1 = 0.0;
9728 double dBrHXXRatio2 = 0.0;
9729 if (fstate==0){
9730 // Use for Cross-section [pb] with no Higgs-boson decay
9731 weight = 0.571956; //Ref: CMS-HIG-21-018-PAS-v3
9732 } else if (fstate == 1){
9733 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9734 dBrHXXRatio1 = BrHXXRatio - 1.0;
9735 dBrHXXRatio2 = 0.0;
9736 } else if (fstate == 2){
9737 BrHXXRatio = (myNPbase->BrHgagaRatio());
9738 dBrHXXRatio1 = BrHXXRatio - 1.0;
9739 dBrHXXRatio2 = 0.0;
9740 } else if (fstate == 3){
9741 BrHXXRatio = (myNPbase->BrHbbRatio());
9742 dBrHXXRatio1 = BrHXXRatio - 1.0;
9743 dBrHXXRatio2 = 0.0;
9744 } else if (fstate == 4){
9745 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9746 dBrHXXRatio1 = BrHXXRatio - 1.0;
9747 dBrHXXRatio2 = 0.0;
9748 } else if (fstate == 5){
9749 BrHXXRatio = (myNPbase->BrHtautauRatio());
9750 dBrHXXRatio1 = BrHXXRatio - 1.0;
9751 dBrHXXRatio2 = 0.0;
9752 } else if (fstate == 6){
9753 BrHXXRatio = (myNPbase->BrHWWRatio());
9754 dBrHXXRatio1 = BrHXXRatio - 1.0;
9755 dBrHXXRatio2 = 0.0;
9756 } else if (fstate == 7){
9757 BrHXXRatio = (myNPbase->BrHZZRatio());
9758 dBrHXXRatio1 = BrHXXRatio - 1.0;
9759 dBrHXXRatio2 = 0.0;
9760 } else {
9761 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9762 }
9763
9764 //-- Production x Decay:
9765 if ((this->getModel()).isModelLinearized()){
9766 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9767 } else if((this->getModel()).isModelNPquadratic()){
9768 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9769 } else {
9770 return weight*(muProd)*(BrHXXRatio);
9771 }
9772
9773
9774
9775
9776}
9777
9778// -----------------------------------------------------------------------------
9779
9781: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9782{
9783 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9784 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9785
9786}
9787
9789{
9790
9791
9792
9793
9794
9795 //-- Production:
9796 double weight = 1.0; //If normalized to the SM
9798 double muProd1 = muProd -1.0;
9799 double muProd2 = 0.0;
9800
9801 //-- Decay:
9802 double BrHXXRatio = 1.0;
9803 double dBrHXXRatio1 = 0.0;
9804 double dBrHXXRatio2 = 0.0;
9805 if (fstate==0){
9806 // Use for Cross-section [pb] with no Higgs-boson decay
9807 weight = 0.1647; //Ref: CMS-HIG-21-018-PAS-v3
9808 } else if (fstate == 1){
9809 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9810 dBrHXXRatio1 = BrHXXRatio - 1.0;
9811 dBrHXXRatio2 = 0.0;
9812 } else if (fstate == 2){
9813 BrHXXRatio = (myNPbase->BrHgagaRatio());
9814 dBrHXXRatio1 = BrHXXRatio - 1.0;
9815 dBrHXXRatio2 = 0.0;
9816 } else if (fstate == 3){
9817 BrHXXRatio = (myNPbase->BrHbbRatio());
9818 dBrHXXRatio1 = BrHXXRatio - 1.0;
9819 dBrHXXRatio2 = 0.0;
9820 } else if (fstate == 4){
9821 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9822 dBrHXXRatio1 = BrHXXRatio - 1.0;
9823 dBrHXXRatio2 = 0.0;
9824 } else if (fstate == 5){
9825 BrHXXRatio = (myNPbase->BrHtautauRatio());
9826 dBrHXXRatio1 = BrHXXRatio - 1.0;
9827 dBrHXXRatio2 = 0.0;
9828 } else if (fstate == 6){
9829 BrHXXRatio = (myNPbase->BrHWWRatio());
9830 dBrHXXRatio1 = BrHXXRatio - 1.0;
9831 dBrHXXRatio2 = 0.0;
9832 } else if (fstate == 7){
9833 BrHXXRatio = (myNPbase->BrHZZRatio());
9834 dBrHXXRatio1 = BrHXXRatio - 1.0;
9835 dBrHXXRatio2 = 0.0;
9836 } else {
9837 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9838 }
9839
9840 //-- Production x Decay:
9841 if ((this->getModel()).isModelLinearized()){
9842 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9843 } else if((this->getModel()).isModelNPquadratic()){
9844 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9845 } else {
9846 return weight*(muProd)*(BrHXXRatio);
9847 }
9848
9849
9850
9851
9852
9853
9854}
9855
9856
9857
9858
9859
9860
9861// -----------------------------------------------------------------------------
9862
9863
9864
9865//VM:STXS2025
9867: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9868{
9869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9870 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9871
9872}
9873
9875{
9876
9877
9878
9879 //-- Production:
9880 double weight = 1.0; //If normalized to the SM
9881 double muProd = (
9884 )/(0.175166+0.1647);
9885 double muProd1 = muProd -1.0;
9886 double muProd2 = 0.0;
9887
9888 //-- Decay:
9889 double BrHXXRatio = 1.0;
9890 double dBrHXXRatio1 = 0.0;
9891 double dBrHXXRatio2 = 0.0;
9892 if (fstate==0){
9893 // Use for Cross-section [pb] with no Higgs-boson decay
9894 weight = 0.1647; //Ref: CMS-HIG-21-018-PAS-v3
9895 } else if (fstate == 1){
9896 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9897 dBrHXXRatio1 = BrHXXRatio - 1.0;
9898 dBrHXXRatio2 = 0.0;
9899 } else if (fstate == 2){
9900 BrHXXRatio = (myNPbase->BrHgagaRatio());
9901 dBrHXXRatio1 = BrHXXRatio - 1.0;
9902 dBrHXXRatio2 = 0.0;
9903 } else if (fstate == 3){
9904 BrHXXRatio = (myNPbase->BrHbbRatio());
9905 dBrHXXRatio1 = BrHXXRatio - 1.0;
9906 dBrHXXRatio2 = 0.0;
9907 } else if (fstate == 4){
9908 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9909 dBrHXXRatio1 = BrHXXRatio - 1.0;
9910 dBrHXXRatio2 = 0.0;
9911 } else if (fstate == 5){
9912 BrHXXRatio = (myNPbase->BrHtautauRatio());
9913 dBrHXXRatio1 = BrHXXRatio - 1.0;
9914 dBrHXXRatio2 = 0.0;
9915 } else if (fstate == 6){
9916 BrHXXRatio = (myNPbase->BrHWWRatio());
9917 dBrHXXRatio1 = BrHXXRatio - 1.0;
9918 dBrHXXRatio2 = 0.0;
9919 } else if (fstate == 7){
9920 BrHXXRatio = (myNPbase->BrHZZRatio());
9921 dBrHXXRatio1 = BrHXXRatio - 1.0;
9922 dBrHXXRatio2 = 0.0;
9923 } else {
9924 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9925 }
9926
9927 //-- Production x Decay:
9928 if ((this->getModel()).isModelLinearized()){
9929 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9930 } else if((this->getModel()).isModelNPquadratic()){
9931 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9932 } else {
9933 return weight*(muProd)*(BrHXXRatio);
9934 }
9935
9936
9937
9938}
9939
9940
9941
9942
9943
9944
9945
9946// -----------------------------------------------------------------------------
9947
9948//AG:STXS2024
9949STXS12_qqHqq_mjj350_700_pTH0_200_Nj2::STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9950: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9951{
9952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9953 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9954
9955}
9956
9958{
9959 //-- Production:
9960 double weight = 1.0; //If normalized to the SM
9962 double muProd1 = muProd -1.0;
9963 double muProd2 = 0.0;
9964
9965 //-- Decay:
9966 double BrHXXRatio = 1.0;
9967 double dBrHXXRatio1 = 0.0;
9968 double dBrHXXRatio2 = 0.0;
9969 if (fstate==0){
9970 // Use for Cross-section [pb] with no Higgs-boson decay
9971 weight = 0.53537; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9972 } else if (fstate == 1){
9973 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9974 dBrHXXRatio1 = BrHXXRatio - 1.0;
9975 dBrHXXRatio2 = 0.0;
9976 } else if (fstate == 2){
9977 BrHXXRatio = (myNPbase->BrHgagaRatio());
9978 dBrHXXRatio1 = BrHXXRatio - 1.0;
9979 dBrHXXRatio2 = 0.0;
9980 } else if (fstate == 3){
9981 BrHXXRatio = (myNPbase->BrHbbRatio());
9982 dBrHXXRatio1 = BrHXXRatio - 1.0;
9983 dBrHXXRatio2 = 0.0;
9984 } else if (fstate == 4){
9985 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9986 dBrHXXRatio1 = BrHXXRatio - 1.0;
9987 dBrHXXRatio2 = 0.0;
9988 } else if (fstate == 5){
9989 BrHXXRatio = (myNPbase->BrHtautauRatio());
9990 dBrHXXRatio1 = BrHXXRatio - 1.0;
9991 dBrHXXRatio2 = 0.0;
9992 } else if (fstate == 6){
9993 BrHXXRatio = (myNPbase->BrHWWRatio());
9994 dBrHXXRatio1 = BrHXXRatio - 1.0;
9995 dBrHXXRatio2 = 0.0;
9996 } else if (fstate == 7){
9997 BrHXXRatio = (myNPbase->BrHZZRatio());
9998 dBrHXXRatio1 = BrHXXRatio - 1.0;
9999 dBrHXXRatio2 = 0.0;
10000 } else {
10001 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10002 }
10003
10004 //-- Production x Decay:
10005 if ((this->getModel()).isModelLinearized()){
10006 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10007 } else if((this->getModel()).isModelNPquadratic()){
10008 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10009 } else {
10010 return weight*(muProd)*(BrHXXRatio);
10011 }
10012
10013
10014}
10015
10016// -----------------------------------------------------------------------------
10017
10018//AG:STXS2024
10019STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2::STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10020: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10021{
10022 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10023 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10024
10025}
10026
10028{
10029 //-- Production:
10030 double weight = 1.0; //If normalized to the SM
10032 double muProd1 = muProd -1.0;
10033 double muProd2 = 0.0;
10034
10035 //-- Decay:
10036 double BrHXXRatio = 1.0;
10037 double dBrHXXRatio1 = 0.0;
10038 double dBrHXXRatio2 = 0.0;
10039 if (fstate==0){
10040 // Use for Cross-section [pb] with no Higgs-boson decay
10041 weight = 0.25614; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10042 } else if (fstate == 1){
10043 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10044 dBrHXXRatio1 = BrHXXRatio - 1.0;
10045 dBrHXXRatio2 = 0.0;
10046 } else if (fstate == 2){
10047 BrHXXRatio = (myNPbase->BrHgagaRatio());
10048 dBrHXXRatio1 = BrHXXRatio - 1.0;
10049 dBrHXXRatio2 = 0.0;
10050 } else if (fstate == 3){
10051 BrHXXRatio = (myNPbase->BrHbbRatio());
10052 dBrHXXRatio1 = BrHXXRatio - 1.0;
10053 dBrHXXRatio2 = 0.0;
10054 } else if (fstate == 4){
10055 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10056 dBrHXXRatio1 = BrHXXRatio - 1.0;
10057 dBrHXXRatio2 = 0.0;
10058 } else if (fstate == 5){
10059 BrHXXRatio = (myNPbase->BrHtautauRatio());
10060 dBrHXXRatio1 = BrHXXRatio - 1.0;
10061 dBrHXXRatio2 = 0.0;
10062 } else if (fstate == 6){
10063 BrHXXRatio = (myNPbase->BrHWWRatio());
10064 dBrHXXRatio1 = BrHXXRatio - 1.0;
10065 dBrHXXRatio2 = 0.0;
10066 } else if (fstate == 7){
10067 BrHXXRatio = (myNPbase->BrHZZRatio());
10068 dBrHXXRatio1 = BrHXXRatio - 1.0;
10069 dBrHXXRatio2 = 0.0;
10070 } else {
10071 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10072 }
10073
10074 //-- Production x Decay:
10075 if ((this->getModel()).isModelLinearized()){
10076 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10077 } else if((this->getModel()).isModelNPquadratic()){
10078 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10079 } else {
10080 return weight*(muProd)*(BrHXXRatio);
10081 }
10082
10083
10084}
10085
10086// -----------------------------------------------------------------------------
10087
10088//AG:STXS2024
10089STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10090: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10091{
10092 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10093 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10094
10095}
10096
10098{
10099 //-- Production:
10100 double weight = 1.0; //If normalized to the SM
10102 double muProd1 = muProd -1.0;
10103 double muProd2 = 0.0;
10104
10105 //-- Decay:
10106 double BrHXXRatio = 1.0;
10107 double dBrHXXRatio1 = 0.0;
10108 double dBrHXXRatio2 = 0.0;
10109 if (fstate==0){
10110 // Use for Cross-section [pb] with no Higgs-boson decay
10111 weight = 0.22408; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10112 } else if (fstate == 1){
10113 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10114 dBrHXXRatio1 = BrHXXRatio - 1.0;
10115 dBrHXXRatio2 = 0.0;
10116 } else if (fstate == 2){
10117 BrHXXRatio = (myNPbase->BrHgagaRatio());
10118 dBrHXXRatio1 = BrHXXRatio - 1.0;
10119 dBrHXXRatio2 = 0.0;
10120 } else if (fstate == 3){
10121 BrHXXRatio = (myNPbase->BrHbbRatio());
10122 dBrHXXRatio1 = BrHXXRatio - 1.0;
10123 dBrHXXRatio2 = 0.0;
10124 } else if (fstate == 4){
10125 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10126 dBrHXXRatio1 = BrHXXRatio - 1.0;
10127 dBrHXXRatio2 = 0.0;
10128 } else if (fstate == 5){
10129 BrHXXRatio = (myNPbase->BrHtautauRatio());
10130 dBrHXXRatio1 = BrHXXRatio - 1.0;
10131 dBrHXXRatio2 = 0.0;
10132 } else if (fstate == 6){
10133 BrHXXRatio = (myNPbase->BrHWWRatio());
10134 dBrHXXRatio1 = BrHXXRatio - 1.0;
10135 dBrHXXRatio2 = 0.0;
10136 } else if (fstate == 7){
10137 BrHXXRatio = (myNPbase->BrHZZRatio());
10138 dBrHXXRatio1 = BrHXXRatio - 1.0;
10139 dBrHXXRatio2 = 0.0;
10140 } else {
10141 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10142 }
10143
10144 //-- Production x Decay:
10145 if ((this->getModel()).isModelLinearized()){
10146 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10147 } else if((this->getModel()).isModelNPquadratic()){
10148 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10149 } else {
10150 return weight*(muProd)*(BrHXXRatio);
10151 }
10152
10153
10154}
10155
10156// -----------------------------------------------------------------------------
10157
10158//AG:STXS2024
10159STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10160: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10161{
10162 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10163 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10164
10165}
10166
10168{
10169 //-- Production:
10170 double weight = 1.0; //If normalized to the SM
10172 double muProd1 = muProd -1.0;
10173 double muProd2 = 0.0;
10174
10175 //-- Decay:
10176 double BrHXXRatio = 1.0;
10177 double dBrHXXRatio1 = 0.0;
10178 double dBrHXXRatio2 = 0.0;
10179 if (fstate==0){
10180 // Use for Cross-section [pb] with no Higgs-boson decay
10181 weight = 0.21578; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10182 } else if (fstate == 1){
10183 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10184 dBrHXXRatio1 = BrHXXRatio - 1.0;
10185 dBrHXXRatio2 = 0.0;
10186 } else if (fstate == 2){
10187 BrHXXRatio = (myNPbase->BrHgagaRatio());
10188 dBrHXXRatio1 = BrHXXRatio - 1.0;
10189 dBrHXXRatio2 = 0.0;
10190 } else if (fstate == 3){
10191 BrHXXRatio = (myNPbase->BrHbbRatio());
10192 dBrHXXRatio1 = BrHXXRatio - 1.0;
10193 dBrHXXRatio2 = 0.0;
10194 } else if (fstate == 4){
10195 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10196 dBrHXXRatio1 = BrHXXRatio - 1.0;
10197 dBrHXXRatio2 = 0.0;
10198 } else if (fstate == 5){
10199 BrHXXRatio = (myNPbase->BrHtautauRatio());
10200 dBrHXXRatio1 = BrHXXRatio - 1.0;
10201 dBrHXXRatio2 = 0.0;
10202 } else if (fstate == 6){
10203 BrHXXRatio = (myNPbase->BrHWWRatio());
10204 dBrHXXRatio1 = BrHXXRatio - 1.0;
10205 dBrHXXRatio2 = 0.0;
10206 } else if (fstate == 7){
10207 BrHXXRatio = (myNPbase->BrHZZRatio());
10208 dBrHXXRatio1 = BrHXXRatio - 1.0;
10209 dBrHXXRatio2 = 0.0;
10210 } else {
10211 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10212 }
10213
10214 //-- Production x Decay:
10215 if ((this->getModel()).isModelLinearized()){
10216 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10217 } else if((this->getModel()).isModelNPquadratic()){
10218 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10219 } else {
10220 return weight*(muProd)*(BrHXXRatio);
10221 }
10222
10223}
10224
10225// -----------------------------------------------------------------------------
10226
10227//AG:STXS2024
10228STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10229: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10230{
10231 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10232 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10233
10234}
10235
10237{
10238 //-- Production:
10239 double weight = 1.0; //If normalized to the SM
10240 //Since adding bins, include partial weigths of SM_predictions
10241 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10242 double muProd = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s))
10244 ) / (0.22408+0.21578);
10245 double muProd1 = muProd - 1.0;
10246 double muProd2 = 0.0;
10247
10248 //-- Decay:
10249 double BrHXXRatio = 1.0;
10250 double dBrHXXRatio1 = 0.0;
10251 double dBrHXXRatio2 = 0.0;
10252 if (fstate==0){
10253 // Use for Cross-section [pb] with no Higgs-boson decay
10254 weight = (0.22408+0.21578) ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10255 } else if (fstate == 1){
10256 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10257 dBrHXXRatio1 = BrHXXRatio - 1.0;
10258 dBrHXXRatio2 = 0.0;
10259 } else if (fstate == 2){
10260 BrHXXRatio = (myNPbase->BrHgagaRatio());
10261 dBrHXXRatio1 = BrHXXRatio - 1.0;
10262 dBrHXXRatio2 = 0.0;
10263 } else if (fstate == 3){
10264 BrHXXRatio = (myNPbase->BrHbbRatio());
10265 dBrHXXRatio1 = BrHXXRatio - 1.0;
10266 dBrHXXRatio2 = 0.0;
10267 } else if (fstate == 4){
10268 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10269 dBrHXXRatio1 = BrHXXRatio - 1.0;
10270 dBrHXXRatio2 = 0.0;
10271 } else if (fstate == 5){
10272 BrHXXRatio = (myNPbase->BrHtautauRatio());
10273 dBrHXXRatio1 = BrHXXRatio - 1.0;
10274 dBrHXXRatio2 = 0.0;
10275 } else if (fstate == 6){
10276 BrHXXRatio = (myNPbase->BrHWWRatio());
10277 dBrHXXRatio1 = BrHXXRatio - 1.0;
10278 dBrHXXRatio2 = 0.0;
10279 } else if (fstate == 7){
10280 BrHXXRatio = (myNPbase->BrHZZRatio());
10281 dBrHXXRatio1 = BrHXXRatio - 1.0;
10282 dBrHXXRatio2 = 0.0;
10283 } else {
10284 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10285 }
10286
10287 //-- Production x Decay:
10288 if ((this->getModel()).isModelLinearized()){
10289 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10290 } else if((this->getModel()).isModelNPquadratic()){
10291 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10292 } else {
10293 return weight*(muProd)*(BrHXXRatio);
10294 }
10295
10296
10297}
10298
10299
10300
10301// -----------------------------------------------------------------------------
10302
10303//VM:STXS2025
10304STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10305: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10306{
10307 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10308 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10309
10310}
10311
10313{
10314 //-- Production:
10315 double weight = 1.0; //If normalized to the SM
10316 //Since adding bins, include partial weigths of SM_predictions
10317 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10318 double muProd = (0.25614*(myNPbase->STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(sqrt_s))
10321 )/(0.25614+0.22408+0.21578);
10322 double muProd1 = (muProd-1.0);
10323 double muProd2 = 0.0;
10324
10325 //-- Decay:
10326 double BrHXXRatio = 1.0;
10327 double dBrHXXRatio1 = 0.0;
10328 double dBrHXXRatio2 = 0.0;
10329 if (fstate==0){
10330 // Use for Cross-section [pb] with no Higgs-boson decay
10331 weight = (0.25614+0.22408+0.21578); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10332 } else if (fstate == 1){
10333 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10334 dBrHXXRatio1 = BrHXXRatio - 1.0;
10335 dBrHXXRatio2 = 0.0;
10336 } else if (fstate == 2){
10337 BrHXXRatio = (myNPbase->BrHgagaRatio());
10338 dBrHXXRatio1 = BrHXXRatio - 1.0;
10339 dBrHXXRatio2 = 0.0;
10340 } else if (fstate == 3){
10341 BrHXXRatio = (myNPbase->BrHbbRatio());
10342 dBrHXXRatio1 = BrHXXRatio - 1.0;
10343 dBrHXXRatio2 = 0.0;
10344 } else if (fstate == 4){
10345 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10346 dBrHXXRatio1 = BrHXXRatio - 1.0;
10347 dBrHXXRatio2 = 0.0;
10348 } else if (fstate == 5){
10349 BrHXXRatio = (myNPbase->BrHtautauRatio());
10350 dBrHXXRatio1 = BrHXXRatio - 1.0;
10351 dBrHXXRatio2 = 0.0;
10352 } else if (fstate == 6){
10353 BrHXXRatio = (myNPbase->BrHWWRatio());
10354 dBrHXXRatio1 = BrHXXRatio - 1.0;
10355 dBrHXXRatio2 = 0.0;
10356 } else if (fstate == 7){
10357 BrHXXRatio = (myNPbase->BrHZZRatio());
10358 dBrHXXRatio1 = BrHXXRatio - 1.0;
10359 dBrHXXRatio2 = 0.0;
10360 } else {
10361 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10362 }
10363
10364 //-- Production x Decay:
10365 if ((this->getModel()).isModelLinearized()){
10366 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10367 } else if((this->getModel()).isModelNPquadratic()){
10368 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10369 } else {
10370 return weight*(muProd)*(BrHXXRatio);
10371 }
10372
10373
10374}
10375
10376
10377
10378
10379// -----------------------------------------------------------------------------
10380
10381//AG:STXS2024
10382STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2::STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10383: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10384{
10385 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10386 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
10387
10388}
10389
10391{
10392 //-- Production:
10393 double weight = 1.0; //If normalized to the SM
10395 double muProd1 = muProd -1.0;
10396 double muProd2 = 0.0;
10397
10398 //-- Decay:
10399 double BrHXXRatio = 1.0;
10400 double dBrHXXRatio1 = 0.0;
10401 double dBrHXXRatio2 = 0.0;
10402 if (fstate==0){
10403 // Use for Cross-section [pb] with no Higgs-boson decay
10404 weight = 0.07372 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10405 } else if (fstate == 1){
10406 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10407 dBrHXXRatio1 = BrHXXRatio - 1.0;
10408 dBrHXXRatio2 = 0.0;
10409 } else if (fstate == 2){
10410 BrHXXRatio = (myNPbase->BrHgagaRatio());
10411 dBrHXXRatio1 = BrHXXRatio - 1.0;
10412 dBrHXXRatio2 = 0.0;
10413 } else if (fstate == 3){
10414 BrHXXRatio = (myNPbase->BrHbbRatio());
10415 dBrHXXRatio1 = BrHXXRatio - 1.0;
10416 dBrHXXRatio2 = 0.0;
10417 } else if (fstate == 4){
10418 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10419 dBrHXXRatio1 = BrHXXRatio - 1.0;
10420 dBrHXXRatio2 = 0.0;
10421 } else {
10422 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
10423 }
10424
10425 //-- Production x Decay:
10426 if ((this->getModel()).isModelLinearized()){
10427 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10428 } else if((this->getModel()).isModelNPquadratic()){
10429 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10430 } else {
10431 return weight*(muProd)*(BrHXXRatio);
10432 }
10433
10434
10435}
10436
10437// -----------------------------------------------------------------------------
10438
10439//AG:STXS2024
10440STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10441: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10442{
10443 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10444 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
10445
10446}
10447
10449{
10450 //-- Production:
10451 double weight = 1.0; //If normalized to the SM
10453 double muProd1 = muProd -1.0;
10454 double muProd2 = 0.0;
10455
10456 //-- Decay:
10457 double BrHXXRatio = 1.0;
10458 double dBrHXXRatio1 = 0.0;
10459 double dBrHXXRatio2 = 0.0;
10460 if (fstate==0){
10461 // Use for Cross-section [pb] with no Higgs-boson decay
10462 weight = 0.07315 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10463 } else if (fstate == 1){
10464 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10465 dBrHXXRatio1 = BrHXXRatio - 1.0;
10466 dBrHXXRatio2 = 0.0;
10467 } else if (fstate == 2){
10468 BrHXXRatio = (myNPbase->BrHgagaRatio());
10469 dBrHXXRatio1 = BrHXXRatio - 1.0;
10470 dBrHXXRatio2 = 0.0;
10471 } else if (fstate == 3){
10472 BrHXXRatio = (myNPbase->BrHbbRatio());
10473 dBrHXXRatio1 = BrHXXRatio - 1.0;
10474 dBrHXXRatio2 = 0.0;
10475 } else if (fstate == 4){
10476 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10477 dBrHXXRatio1 = BrHXXRatio - 1.0;
10478 dBrHXXRatio2 = 0.0;
10479 } else {
10480 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
10481 }
10482
10483 //-- Production x Decay:
10484 if ((this->getModel()).isModelLinearized()){
10485 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10486 } else if((this->getModel()).isModelNPquadratic()){
10487 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10488 } else {
10489 return weight*(muProd)*(BrHXXRatio);
10490 }
10491
10492
10493}
10494
10495// -----------------------------------------------------------------------------
10496
10497STXS12_qqHqq_mjj350_Inf_Nj2::STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10498: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10499{
10500 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10501 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with a class whose parent is not NPbase");
10502
10503}
10504
10506{
10507 //-- Production:
10508 double weight = 1.0; //If normalized to the SM
10509 //Since adding bins, include partial weigths of SM_predictions
10510 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10511
10512 double muProd = (0.53537*myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(sqrt_s)
10518 / (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315) ;
10519
10520 double muProd1 = muProd - 1.;
10521 double muProd2 = 0.0;
10522
10523 //-- Decay:
10524 double BrHXXRatio = 1.0;
10525 double dBrHXXRatio1 = 0.0;
10526 double dBrHXXRatio2 = 0.0;
10527 if (fstate==0){
10528 // Use for Cross-section [pb] with no Higgs-boson decay
10529 weight = (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315); //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
10530 } else if (fstate == 1){
10531 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10532 dBrHXXRatio1 = BrHXXRatio - 1.0;
10533 dBrHXXRatio2 = 0.0;
10534 } else if (fstate == 2){
10535 BrHXXRatio = (myNPbase->BrHgagaRatio());
10536 dBrHXXRatio1 = BrHXXRatio - 1.0;
10537 dBrHXXRatio2 = 0.0;
10538 } else if (fstate == 3){
10539 BrHXXRatio = (myNPbase->BrHbbRatio());
10540 dBrHXXRatio1 = BrHXXRatio - 1.0;
10541 dBrHXXRatio2 = 0.0;
10542 } else if (fstate == 4){
10543 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10544 dBrHXXRatio1 = BrHXXRatio - 1.0;
10545 dBrHXXRatio2 = 0.0;
10546 } else if (fstate == 5){
10547 BrHXXRatio = (myNPbase->BrHtautauRatio());
10548 dBrHXXRatio1 = BrHXXRatio - 1.0;
10549 dBrHXXRatio2 = 0.0;
10550 } else {
10551 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10552 }
10553
10554
10555
10556
10557 //-- Production x Decay:
10558 if ((this->getModel()).isModelLinearized()){
10559// std::cout<<"\033[1;31m CHECK IF LINEAR \033[0m" << std::endl;
10560 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10561 } else if((this->getModel()).isModelNPquadratic()){
10562// std::cout<<"\033[1;31m CHECK IF QUADRATIC \033[0m" << std::endl;
10563 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10564 } else {
10565// std::cout<<"\033[1;31m CHECK IF NEITHER LINEAR NOR QUADRATIC \033[0m" << std::endl;
10566 return weight*(muProd)*(BrHXXRatio);
10567 }
10568
10569}
10570
10571// -----------------------------------------------------------------------------
10572
10573STXS12_qqHlv_pTV0_75::STXS12_qqHlv_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10574: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10575{
10576 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10577 throw std::runtime_error("STXS12_qqHlv_pTV0_75 called with a class whose parent is not NPbase");
10578
10579}
10580
10582{
10583 //-- Production:
10584 double weight = 1.0; //If normalized to the SM
10585 double muProd = myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s);
10586 double muProd1 = muProd -1.0;
10587 double muProd2 = 0.0;
10588
10589 //-- Decay:
10590 double BrHXXRatio = 1.0;
10591 double dBrHXXRatio1 = 0.0;
10592 double dBrHXXRatio2 = 0.0;
10593 if (fstate==0){
10594 // Use for Cross-section [pb] with no Higgs-boson decay
10595 weight = 0.21509; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10596 } else if (fstate == 1){
10597 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10598 dBrHXXRatio1 = BrHXXRatio - 1.0;
10599 dBrHXXRatio2 = 0.0;
10600 } else if (fstate == 2){
10601 BrHXXRatio = (myNPbase->BrHgagaRatio());
10602 dBrHXXRatio1 = BrHXXRatio - 1.0;
10603 dBrHXXRatio2 = 0.0;
10604 } else if (fstate == 3){
10605 BrHXXRatio = (myNPbase->BrHbbRatio());
10606 dBrHXXRatio1 = BrHXXRatio - 1.0;
10607 dBrHXXRatio2 = 0.0;
10608 } else if (fstate == 4){
10609 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10610 dBrHXXRatio1 = BrHXXRatio - 1.0;
10611 dBrHXXRatio2 = 0.0;
10612 } else if (fstate == 5){
10613 BrHXXRatio = (myNPbase->BrHtautauRatio());
10614 dBrHXXRatio1 = BrHXXRatio - 1.0;
10615 dBrHXXRatio2 = 0.0;
10616 } else {
10617 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10618 }
10619
10620 //-- Production x Decay:
10621 if ((this->getModel()).isModelLinearized()){
10622 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10623 } else if((this->getModel()).isModelNPquadratic()){
10624 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10625 } else {
10626 return weight*(muProd)*(BrHXXRatio);
10627 }
10628
10629}
10630
10631// -----------------------------------------------------------------------------
10632
10633STXS12_qqHlv_pTV75_150::STXS12_qqHlv_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10634: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10635{
10636 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10637 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with a class whose parent is not NPbase");
10638
10639}
10640
10642{
10643 //-- Production:
10644 double weight = 1.0; //If normalized to the SM
10645 double muProd = myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s);
10646 double muProd1 = muProd -1.0;
10647 double muProd2 = 0.0;
10648
10649 //-- Decay:
10650 double BrHXXRatio = 1.0;
10651 double dBrHXXRatio1 = 0.0;
10652 double dBrHXXRatio2 = 0.0;
10653 if (fstate==0){
10654 // Use for Cross-section [pb] with no Higgs-boson decay
10655 weight = 0.13440; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10656 } else if (fstate == 1){
10657 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10658 dBrHXXRatio1 = BrHXXRatio - 1.0;
10659 dBrHXXRatio2 = 0.0;
10660 } else if (fstate == 2){
10661 BrHXXRatio = (myNPbase->BrHgagaRatio());
10662 dBrHXXRatio1 = BrHXXRatio - 1.0;
10663 dBrHXXRatio2 = 0.0;
10664 } else if (fstate == 3){
10665 BrHXXRatio = (myNPbase->BrHbbRatio());
10666 dBrHXXRatio1 = BrHXXRatio - 1.0;
10667 dBrHXXRatio2 = 0.0;
10668 } else if (fstate == 4){
10669 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10670 dBrHXXRatio1 = BrHXXRatio - 1.0;
10671 dBrHXXRatio2 = 0.0;
10672 } else if (fstate == 5){
10673 BrHXXRatio = (myNPbase->BrHtautauRatio());
10674 dBrHXXRatio1 = BrHXXRatio - 1.0;
10675 dBrHXXRatio2 = 0.0;
10676 } else {
10677 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with invalid argument for final state in fstate_i");
10678 }
10679
10680 //-- Production x Decay:
10681 if ((this->getModel()).isModelLinearized()){
10682 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10683 } else if((this->getModel()).isModelNPquadratic()){
10684 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10685 } else {
10686 return weight*(muProd)*(BrHXXRatio);
10687 }
10688
10689}
10690
10691// -----------------------------------------------------------------------------
10692
10693//AG:STXS2024
10694STXS12_qqHlv_pTV150_250_Nj0::STXS12_qqHlv_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10695: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10696{
10697 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10698 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10699
10700}
10701
10703{
10704 //-- Production:
10705 double weight = 1.0; //If normalized to the SM
10707 double muProd1 = myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) - 1.0;
10708 double muProd2 = 0.0;
10709
10710 //-- Decay:
10711 double BrHXXRatio = 1.0;
10712 double dBrHXXRatio1 = 0.0;
10713 double dBrHXXRatio2 = 0.0;
10714 if (fstate==0){
10715 // Use for Cross-section [pb] with no Higgs-boson decay
10716 weight = 0.04117; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10717 } else if (fstate == 1){
10718 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10719 dBrHXXRatio1 = BrHXXRatio - 1.0;
10720 dBrHXXRatio2 = 0.0;
10721 } else if (fstate == 2){
10722 BrHXXRatio = (myNPbase->BrHgagaRatio());
10723 dBrHXXRatio1 = BrHXXRatio - 1.0;
10724 dBrHXXRatio2 = 0.0;
10725 } else if (fstate == 3){
10726 BrHXXRatio = (myNPbase->BrHbbRatio());
10727 dBrHXXRatio1 = BrHXXRatio - 1.0;
10728 dBrHXXRatio2 = 0.0;
10729 } else if (fstate == 4){
10730 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10731 dBrHXXRatio1 = BrHXXRatio - 1.0;
10732 dBrHXXRatio2 = 0.0;
10733 } else if (fstate == 5){
10734 BrHXXRatio = (myNPbase->BrHtautauRatio());
10735 dBrHXXRatio1 = BrHXXRatio - 1.0;
10736 dBrHXXRatio2 = 0.0;
10737 } else {
10738 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10739 }
10740
10741 //-- Production x Decay:
10742 if ((this->getModel()).isModelLinearized()){
10743 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10744 } else if((this->getModel()).isModelNPquadratic()){
10745 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10746 } else {
10747 return weight*(muProd)*(BrHXXRatio);
10748 }
10749
10750
10751}
10752
10753// -----------------------------------------------------------------------------
10754
10755
10756
10757
10758
10759
10760STXS12_qqHlv_pTV150_250_Nj1::STXS12_qqHlv_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10761: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10762{
10763 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10764 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10765
10766}
10767
10769{
10770 double BrHXXRatio = 1.0;
10771 if (fstate == 1){
10772 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10773 } else if (fstate == 2){
10774 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10775 } else if (fstate == 3){
10776 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10777 } else if (fstate == 4){
10778 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10779 } else {
10780 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10781 }
10782
10783 if ((this->getModel()).isModelLinearized()) {
10784 return ((myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10785 } else {
10786 return (myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10787 }
10788}
10789
10790// -----------------------------------------------------------------------------
10791
10792STXS12_qqHlv_pTV250_Inf::STXS12_qqHlv_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10793: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10794{
10795 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10796 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with a class whose parent is not NPbase");
10797
10798}
10799
10801{
10802
10803 //-- Production:
10804 double weight = 1.0; //If normalized to the SM
10805 //Since adding bins, include partial weigths of SM_predictions
10806 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10807 double muProd = (myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s));
10808 double muProd1 = (muProd -1.);
10809 double muProd2 = 0.0;
10810
10811 //-- Decay:
10812 double BrHXXRatio = 1.0;
10813 double dBrHXXRatio1 = 0.0;
10814 double dBrHXXRatio2 = 0.0;
10815 if (fstate==0){
10816 // Use for Cross-section [pb] with no Higgs-boson decay
10817 weight = (0.01127+0.00339) ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10818 } else if (fstate == 1){
10819 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10820 dBrHXXRatio1 = BrHXXRatio - 1.0;
10821 dBrHXXRatio2 = 0.0;
10822 } else if (fstate == 2){
10823 BrHXXRatio = (myNPbase->BrHgagaRatio());
10824 dBrHXXRatio1 = BrHXXRatio - 1.0;
10825 dBrHXXRatio2 = 0.0;
10826 } else if (fstate == 3){
10827 BrHXXRatio = (myNPbase->BrHbbRatio());
10828 dBrHXXRatio1 = BrHXXRatio - 1.0;
10829 dBrHXXRatio2 = 0.0;
10830 } else if (fstate == 4){
10831 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10832 dBrHXXRatio1 = BrHXXRatio - 1.0;
10833 dBrHXXRatio2 = 0.0;
10834 } else if (fstate == 5){
10835 BrHXXRatio = (myNPbase->BrHtautauRatio());
10836 dBrHXXRatio1 = BrHXXRatio - 1.0;
10837 dBrHXXRatio2 = 0.0;
10838 } else if (fstate == 6){
10839 BrHXXRatio = (myNPbase->BrHWWRatio());
10840 dBrHXXRatio1 = BrHXXRatio - 1.0;
10841 dBrHXXRatio2 = 0.0;
10842 } else if (fstate == 7){
10843 BrHXXRatio = (myNPbase->BrHZZRatio());
10844 dBrHXXRatio1 = BrHXXRatio - 1.0;
10845 dBrHXXRatio2 = 0.0;
10846 } else {
10847 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with invalid argument for final state in fstate_i");
10848 }
10849
10850 //-- Production x Decay:
10851 if ((this->getModel()).isModelLinearized()){
10852 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10853 } else if((this->getModel()).isModelNPquadratic()){
10854 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10855 } else {
10856 return weight*(muProd)*(BrHXXRatio);
10857 }
10858
10859
10860}
10861
10862// -----------------------------------------------------------------------------
10863
10864//AG:STXS2024
10865STXS12_qqHlv_pTV0_150::STXS12_qqHlv_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10866: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10867{
10868 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10869 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with a class whose parent is not NPbase");
10870
10871}
10872
10874{
10875 //-- Production:
10876 double weight = 1.0; //If normalized to the SM
10877 //Since adding bins, include partial weigths of SM_predictions
10878 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10879 double muProd = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s))
10880 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s))/(0.21509+0.13440));
10881 double muProd1 = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10882 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)/(0.21509+0.13440));
10883 double muProd2 = 0.0;
10884
10885 //-- Decay:
10886 double BrHXXRatio = 1.0;
10887 double dBrHXXRatio1 = 0.0;
10888 double dBrHXXRatio2 = 0.0;
10889 if (fstate==0){
10890 // Use for Cross-section [pb] with no Higgs-boson decay
10891 weight = (0.21509+0.13440) ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10892 } else if (fstate == 1){
10893 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10894 dBrHXXRatio1 = BrHXXRatio - 1.0;
10895 dBrHXXRatio2 = 0.0;
10896 } else if (fstate == 2){
10897 BrHXXRatio = (myNPbase->BrHgagaRatio());
10898 dBrHXXRatio1 = BrHXXRatio - 1.0;
10899 dBrHXXRatio2 = 0.0;
10900 } else if (fstate == 3){
10901 BrHXXRatio = (myNPbase->BrHbbRatio());
10902 dBrHXXRatio1 = BrHXXRatio - 1.0;
10903 dBrHXXRatio2 = 0.0;
10904 } else if (fstate == 4){
10905 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10906 dBrHXXRatio1 = BrHXXRatio - 1.0;
10907 dBrHXXRatio2 = 0.0;
10908 } else if (fstate == 5){
10909 BrHXXRatio = (myNPbase->BrHtautauRatio());
10910 dBrHXXRatio1 = BrHXXRatio - 1.0;
10911 dBrHXXRatio2 = 0.0;
10912 } else if (fstate == 6){
10913 BrHXXRatio = (myNPbase->BrHWWRatio());
10914 dBrHXXRatio1 = BrHXXRatio - 1.0;
10915 dBrHXXRatio2 = 0.0;
10916 } else if (fstate == 7){
10917 BrHXXRatio = (myNPbase->BrHZZRatio());
10918 dBrHXXRatio1 = BrHXXRatio - 1.0;
10919 dBrHXXRatio2 = 0.0;
10920 } else {
10921 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with invalid argument for final state in fstate_i");
10922 }
10923
10924 //-- Production x Decay:
10925 if ((this->getModel()).isModelLinearized()){
10926 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10927 } else if((this->getModel()).isModelNPquadratic()){
10928 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10929 } else {
10930 return weight*(muProd)*(BrHXXRatio);
10931 }
10932
10933
10934}
10935
10936// -----------------------------------------------------------------------------
10937
10938//AG:STXS2024
10939STXS12_qqHlv_pTV150_Inf::STXS12_qqHlv_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10940: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10941{
10942 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10943 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with a class whose parent is not NPbase");
10944
10945}
10946
10948{
10949 //-- Production:
10950 double weight = 1.0; //If normalized to the SM
10951 //Since adding bins, include partial weigths of SM_predictions
10952 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10953 double muProd = (0.04117 * myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s)
10955 + 0.00214 * myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) )/(0.04117+0.01004+0.00214);
10956 double muProd1 = (0.04117 * (myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) -1.0)
10957 + 0.01004 * (myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10958 + 0.00214 * (myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0) )/(0.04117+0.01004+0.00214);
10959 double muProd2 = 0.0;
10960
10961 //-- Decay:
10962 double BrHXXRatio = 1.0;
10963 double dBrHXXRatio1 = 0.0;
10964 double dBrHXXRatio2 = 0.0;
10965 if (fstate==0){
10966 // Use for Cross-section [pb] with no Higgs-boson decay
10967 weight = (0.04117+0.01004+0.00214) ;
10968 } else if (fstate == 1){
10969 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10970 dBrHXXRatio1 = BrHXXRatio - 1.0;
10971 dBrHXXRatio2 = 0.0;
10972 } else if (fstate == 2){
10973 BrHXXRatio = (myNPbase->BrHgagaRatio());
10974 dBrHXXRatio1 = BrHXXRatio - 1.0;
10975 dBrHXXRatio2 = 0.0;
10976 } else if (fstate == 3){
10977 BrHXXRatio = (myNPbase->BrHbbRatio());
10978 dBrHXXRatio1 = BrHXXRatio - 1.0;
10979 dBrHXXRatio2 = 0.0;
10980 } else if (fstate == 4){
10981 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10982 dBrHXXRatio1 = BrHXXRatio - 1.0;
10983 dBrHXXRatio2 = 0.0;
10984 } else if (fstate == 5){
10985 BrHXXRatio = (myNPbase->BrHtautauRatio());
10986 dBrHXXRatio1 = BrHXXRatio - 1.0;
10987 dBrHXXRatio2 = 0.0;
10988 } else if (fstate == 6){
10989 BrHXXRatio = (myNPbase->BrHWWRatio());
10990 dBrHXXRatio1 = BrHXXRatio - 1.0;
10991 dBrHXXRatio2 = 0.0;
10992 } else if (fstate == 7){
10993 BrHXXRatio = (myNPbase->BrHZZRatio());
10994 dBrHXXRatio1 = BrHXXRatio - 1.0;
10995 dBrHXXRatio2 = 0.0;
10996 } else {
10997 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with invalid argument for final state in fstate_i");
10998 }
10999
11000 //-- Production x Decay:
11001 if ((this->getModel()).isModelLinearized()){
11002 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11003 } else if((this->getModel()).isModelNPquadratic()){
11004 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11005 } else {
11006 return weight*(muProd)*(BrHXXRatio);
11007 }
11008
11009
11010}
11011
11012// -----------------------------------------------------------------------------
11013
11014//AG:STXS2024
11015STXS12_qqHlv_pTV250_400::STXS12_qqHlv_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11016: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11017{
11018 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11019 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with a class whose parent is not NPbase");
11020
11021}
11022
11024{
11025 //-- Production:
11026 double weight = 1.0; //If normalized to the SM
11027 double muProd = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s) ;
11028 double muProd1 = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0 ;
11029 double muProd2 = 0.0;
11030
11031 //-- Decay:
11032 double BrHXXRatio = 1.0;
11033 double dBrHXXRatio1 = 0.0;
11034 double dBrHXXRatio2 = 0.0;
11035 if (fstate==0){
11036 // Use for Cross-section [pb] with no Higgs-boson decay
11037 weight =0.01004 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11038 } else if (fstate == 1){
11039 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11040 dBrHXXRatio1 = BrHXXRatio - 1.0;
11041 dBrHXXRatio2 = 0.0;
11042 } else if (fstate == 2){
11043 BrHXXRatio = (myNPbase->BrHgagaRatio());
11044 dBrHXXRatio1 = BrHXXRatio - 1.0;
11045 dBrHXXRatio2 = 0.0;
11046 } else if (fstate == 3){
11047 BrHXXRatio = (myNPbase->BrHbbRatio());
11048 dBrHXXRatio1 = BrHXXRatio - 1.0;
11049 dBrHXXRatio2 = 0.0;
11050 } else if (fstate == 4){
11051 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11052 dBrHXXRatio1 = BrHXXRatio - 1.0;
11053 dBrHXXRatio2 = 0.0;
11054 } else {
11055 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with invalid argument for final state in fstate_i");
11056 }
11057
11058 //-- Production x Decay:
11059 if ((this->getModel()).isModelLinearized()){
11060 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11061 } else if((this->getModel()).isModelNPquadratic()){
11062 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11063 } else {
11064 return weight*(muProd)*(BrHXXRatio);
11065 }
11066
11067
11068}
11069
11070// -----------------------------------------------------------------------------
11071
11072//AG:STXS2024
11073STXS12_qqHlv_pTV400_Inf::STXS12_qqHlv_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11074: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11075{
11076 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11077 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with a class whose parent is not NPbase");
11078
11079}
11080
11082{
11083 //-- Production:
11084 double weight = 1.0; //If normalized to the SM
11085 double muProd = myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) ;
11086 double muProd1 = muProd-1.0 ;
11087 double muProd2 = 0.0;
11088
11089 //-- Decay:
11090 double BrHXXRatio = 1.0;
11091 double dBrHXXRatio1 = 0.0;
11092 double dBrHXXRatio2 = 0.0;
11093 if (fstate==0){
11094 // Use for Cross-section [pb] with no Higgs-boson decay
11095 weight =0.00214 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11096 } else if (fstate == 1){
11097 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11098 dBrHXXRatio1 = BrHXXRatio - 1.0;
11099 dBrHXXRatio2 = 0.0;
11100 } else if (fstate == 2){
11101 BrHXXRatio = (myNPbase->BrHgagaRatio());
11102 dBrHXXRatio1 = BrHXXRatio - 1.0;
11103 dBrHXXRatio2 = 0.0;
11104 } else if (fstate == 3){
11105 BrHXXRatio = (myNPbase->BrHbbRatio());
11106 dBrHXXRatio1 = BrHXXRatio - 1.0;
11107 dBrHXXRatio2 = 0.0;
11108 } else if (fstate == 4){
11109 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11110 dBrHXXRatio1 = BrHXXRatio - 1.0;
11111 dBrHXXRatio2 = 0.0;
11112 } else {
11113 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with invalid argument for final state in fstate_i");
11114 }
11115
11116 //-- Production x Decay:
11117 if ((this->getModel()).isModelLinearized()){
11118 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11119 } else if((this->getModel()).isModelNPquadratic()){
11120 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11121 } else {
11122 return weight*(muProd)*(BrHXXRatio);
11123 }
11124
11125
11126}
11127
11128
11129// -----------------------------------------------------------------------------
11130
11131STXS12_qqHll_pTV0_75::STXS12_qqHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11132: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11133{
11134 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11135 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with a class whose parent is not NPbase");
11136
11137}
11138
11140{
11141 double BrHXXRatio = 1.0;
11142 if (fstate == 1){
11143 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11144 } else if (fstate == 2){
11145 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
11146 } else if (fstate == 3){
11147 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
11148 } else if (fstate == 4){
11149 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11150 } else {
11151 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with invalid argument for final state in fstate_i");
11152 }
11153
11154 if ((this->getModel()).isModelLinearized()) {
11155 return ((myNPbase->STXS12_qqHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
11156 } else {
11157 return (myNPbase->STXS12_qqHll_pTV0_75(sqrt_s))*(BrHXXRatio);
11158 }
11159}
11160
11161// -----------------------------------------------------------------------------
11162
11163//AG:STXS2024
11164STXS12_qqHll_pTV75_150::STXS12_qqHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11165: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11166{
11167 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11168 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with a class whose parent is not NPbase");
11169
11170}
11171
11173{
11174 //-- Production:
11175 double weight = 1.0; //If normalized to the SM
11176 double muProd = myNPbase->STXS12_qqHll_pTV75_150(sqrt_s);
11177 double muProd1 = muProd -1.0;
11178 double muProd2 = 0.0;
11179
11180 //-- Decay:
11181 double BrHXXRatio = 1.0;
11182 double dBrHXXRatio1 = 0.0;
11183 double dBrHXXRatio2 = 0.0;
11184 if (fstate==0){
11185 // Use for Cross-section [pb] with no Higgs-boson decay
11186 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11187 } else if (fstate == 1){
11188 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11189 dBrHXXRatio1 = BrHXXRatio - 1.0;
11190 dBrHXXRatio2 = 0.0;
11191 } else if (fstate == 2){
11192 BrHXXRatio = (myNPbase->BrHgagaRatio());
11193 dBrHXXRatio1 = BrHXXRatio - 1.0;
11194 dBrHXXRatio2 = 0.0;
11195 } else if (fstate == 3){
11196 BrHXXRatio = (myNPbase->BrHbbRatio());
11197 dBrHXXRatio1 = BrHXXRatio - 1.0;
11198 dBrHXXRatio2 = 0.0;
11199 } else if (fstate == 4){
11200 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11201 dBrHXXRatio1 = BrHXXRatio - 1.0;
11202 dBrHXXRatio2 = 0.0;
11203 } else {
11204 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with invalid argument for final state in fstate_i");
11205 }
11206
11207 //-- Production x Decay:
11208 if ((this->getModel()).isModelLinearized()){
11209 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11210 } else if((this->getModel()).isModelNPquadratic()){
11211 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11212 } else {
11213 return weight*(muProd)*(BrHXXRatio);
11214 }
11215
11216
11217}
11218
11219// -----------------------------------------------------------------------------
11220
11221//AG:STXS2024
11222STXS12_qqHll_pTV150_250_Nj0::STXS12_qqHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11223: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11224{
11225 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11226 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
11227
11228}
11229
11231{
11232 //-- Production:
11233 double weight = 1.0; //If normalized to the SM
11235 double muProd1 = muProd -1.0;
11236 double muProd2 = 0.0;
11237
11238 //-- Decay:
11239 double BrHXXRatio = 1.0;
11240 double dBrHXXRatio1 = 0.0;
11241 double dBrHXXRatio2 = 0.0;
11242 if (fstate==0){
11243 // Use for Cross-section [pb] with no Higgs-boson decay
11244 weight = 0.0147 ; //Ref: CMS-21-018-PAS-v3
11245 } else if (fstate == 1){
11246 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11247 dBrHXXRatio1 = BrHXXRatio - 1.0;
11248 dBrHXXRatio2 = 0.0;
11249 } else if (fstate == 2){
11250 BrHXXRatio = (myNPbase->BrHgagaRatio());
11251 dBrHXXRatio1 = BrHXXRatio - 1.0;
11252 dBrHXXRatio2 = 0.0;
11253 } else if (fstate == 3){
11254 BrHXXRatio = (myNPbase->BrHbbRatio());
11255 dBrHXXRatio1 = BrHXXRatio - 1.0;
11256 dBrHXXRatio2 = 0.0;
11257 } else if (fstate == 4){
11258 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11259 dBrHXXRatio1 = BrHXXRatio - 1.0;
11260 dBrHXXRatio2 = 0.0;
11261 } else {
11262 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
11263 }
11264
11265 //-- Production x Decay:
11266 if ((this->getModel()).isModelLinearized()){
11267 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11268 } else if((this->getModel()).isModelNPquadratic()){
11269 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11270 } else {
11271 return weight*(muProd)*(BrHXXRatio);
11272 }
11273
11274}
11275
11276// -----------------------------------------------------------------------------
11277
11278STXS12_qqHll_pTV150_250_Nj1::STXS12_qqHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11279: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11280{
11281 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11282 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
11283
11284}
11285
11287{
11288
11289 //-- Production:
11290 double weight = 1.0; //If normalized to the SM
11292 double muProd1 = muProd -1.0;
11293 double muProd2 = 0.0;
11294
11295 //-- Decay:
11296 double BrHXXRatio = 1.0;
11297 double dBrHXXRatio1 = 0.0;
11298 double dBrHXXRatio2 = 0.0;
11299 if (fstate==0){
11300 // Use for Cross-section [pb] with no Higgs-boson decay
11301 weight = (0.0168) ; //Ref: CMS-21-018-PAS-v3
11302 } else if (fstate == 1){
11303 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11304 dBrHXXRatio1 = BrHXXRatio - 1.0;
11305 dBrHXXRatio2 = 0.0;
11306 } else if (fstate == 2){
11307 BrHXXRatio = (myNPbase->BrHgagaRatio());
11308 dBrHXXRatio1 = BrHXXRatio - 1.0;
11309 dBrHXXRatio2 = 0.0;
11310 } else if (fstate == 3){
11311 BrHXXRatio = (myNPbase->BrHbbRatio());
11312 dBrHXXRatio1 = BrHXXRatio - 1.0;
11313 dBrHXXRatio2 = 0.0;
11314 } else if (fstate == 4){
11315 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11316 dBrHXXRatio1 = BrHXXRatio - 1.0;
11317 dBrHXXRatio2 = 0.0;
11318 } else {
11319 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
11320 }
11321
11322 //-- Production x Decay:
11323 if ((this->getModel()).isModelLinearized()){
11324 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11325 } else if((this->getModel()).isModelNPquadratic()){
11326 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11327 } else {
11328 return weight*(muProd)*(BrHXXRatio);
11329 }
11330
11331
11332
11333
11334
11335}
11336
11337// -----------------------------------------------------------------------------
11338
11339STXS12_qqHll_pTV250_Inf::STXS12_qqHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11340: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11341{
11342 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11343 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with a class whose parent is not NPbase");
11344
11345}
11346
11348{
11349 double BrHXXRatio = 1.0;
11350 if (fstate == 1){
11351 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11352 } else if (fstate == 2){
11353 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
11354 } else if (fstate == 3){
11355 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
11356 } else if (fstate == 4){
11357 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11358 } else {
11359 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with invalid argument for final state in fstate_i");
11360 }
11361
11362 if ((this->getModel()).isModelLinearized()) {
11363 return ((myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
11364 } else {
11365 return (myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
11366 }
11367}
11368
11369
11370// -----------------------------------------------------------------------------
11371
11372//AG:STXS2024
11373STXS12_qqHll_pTV0_150::STXS12_qqHll_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11374: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11375{
11376 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11377 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with a class whose parent is not NPbase");
11378
11379}
11380
11382{
11383 //-- Production:
11384 double weight = 1.0; //If normalized to the SM
11385 double muProd = myNPbase->STXS12_qqHll_pTV0_150(sqrt_s);
11386 double muProd1 = muProd -1.0;
11387 double muProd2 = 0.0;
11388
11389 //-- Decay:
11390 double BrHXXRatio = 1.0;
11391 double dBrHXXRatio1 = 0.0;
11392 double dBrHXXRatio2 = 0.0;
11393 if (fstate==0){
11394 // Use for Cross-section [pb] with no Higgs-boson decay
11395 weight = 0.19845 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11396 } else if (fstate == 1){
11397 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11398 dBrHXXRatio1 = BrHXXRatio - 1.0;
11399 dBrHXXRatio2 = 0.0;
11400 } else if (fstate == 2){
11401 BrHXXRatio = (myNPbase->BrHgagaRatio());
11402 dBrHXXRatio1 = BrHXXRatio - 1.0;
11403 dBrHXXRatio2 = 0.0;
11404 } else if (fstate == 3){
11405 BrHXXRatio = (myNPbase->BrHbbRatio());
11406 dBrHXXRatio1 = BrHXXRatio - 1.0;
11407 dBrHXXRatio2 = 0.0;
11408 } else if (fstate == 4){
11409 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11410 dBrHXXRatio1 = BrHXXRatio - 1.0;
11411 dBrHXXRatio2 = 0.0;
11412 } else if (fstate == 5){
11413 BrHXXRatio = (myNPbase->BrHtautauRatio());
11414 dBrHXXRatio1 = BrHXXRatio - 1.0;
11415 dBrHXXRatio2 = 0.0;
11416 } else if (fstate == 6){
11417 BrHXXRatio = (myNPbase->BrHWWRatio());
11418 dBrHXXRatio1 = BrHXXRatio - 1.0;
11419 dBrHXXRatio2 = 0.0;
11420 } else if (fstate == 7){
11421 BrHXXRatio = (myNPbase->BrHZZRatio());
11422 dBrHXXRatio1 = BrHXXRatio - 1.0;
11423 dBrHXXRatio2 = 0.0;
11424 } else {
11425 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with invalid argument for final state in fstate_i");
11426 }
11427
11428 //-- Production x Decay:
11429 if ((this->getModel()).isModelLinearized()){
11430 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11431 } else if((this->getModel()).isModelNPquadratic()){
11432 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11433 } else {
11434 return weight*(muProd)*(BrHXXRatio);
11435 }
11436
11437}
11438
11439// -----------------------------------------------------------------------------
11440
11441//AG:STXS2024
11442STXS12_qqHll_pTV250_400::STXS12_qqHll_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11443: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11444{
11445 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11446 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with a class whose parent is not NPbase");
11447
11448}
11449
11451{
11452 //-- Production:
11453 double weight = 1.0; //If normalized to the SM
11454 double muProd = myNPbase->STXS12_qqHll_pTV250_400(sqrt_s);
11455 double muProd1 = muProd -1.0;
11456 double muProd2 = 0.0;
11457
11458 //-- Decay:
11459 double BrHXXRatio = 1.0;
11460 double dBrHXXRatio1 = 0.0;
11461 double dBrHXXRatio2 = 0.0;
11462 if (fstate==0){
11463 // Use for Cross-section [pb] with no Higgs-boson decay
11464 weight = 0.00715 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11465 } else if (fstate == 1){
11466 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11467 dBrHXXRatio1 = BrHXXRatio - 1.0;
11468 dBrHXXRatio2 = 0.0;
11469 } else if (fstate == 2){
11470 BrHXXRatio = (myNPbase->BrHgagaRatio());
11471 dBrHXXRatio1 = BrHXXRatio - 1.0;
11472 dBrHXXRatio2 = 0.0;
11473 } else if (fstate == 3){
11474 BrHXXRatio = (myNPbase->BrHbbRatio());
11475 dBrHXXRatio1 = BrHXXRatio - 1.0;
11476 dBrHXXRatio2 = 0.0;
11477 } else if (fstate == 4){
11478 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11479 dBrHXXRatio1 = BrHXXRatio - 1.0;
11480 dBrHXXRatio2 = 0.0;
11481 } else if (fstate == 5){
11482 BrHXXRatio = (myNPbase->BrHtautauRatio());
11483 dBrHXXRatio1 = BrHXXRatio - 1.0;
11484 dBrHXXRatio2 = 0.0;
11485 } else if (fstate == 6){
11486 BrHXXRatio = (myNPbase->BrHWWRatio());
11487 dBrHXXRatio1 = BrHXXRatio - 1.0;
11488 dBrHXXRatio2 = 0.0;
11489 } else if (fstate == 7){
11490 BrHXXRatio = (myNPbase->BrHZZRatio());
11491 dBrHXXRatio1 = BrHXXRatio - 1.0;
11492 dBrHXXRatio2 = 0.0;
11493 } else {
11494 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with invalid argument for final state in fstate_i");
11495 }
11496
11497 //-- Production x Decay:
11498 if ((this->getModel()).isModelLinearized()){
11499 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11500 } else if((this->getModel()).isModelNPquadratic()){
11501 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11502 } else {
11503 return weight*(muProd)*(BrHXXRatio);
11504 }
11505
11506}
11507
11508// -----------------------------------------------------------------------------
11509
11510//AG:STXS2024
11511STXS12_qqHll_pTV400_Inf::STXS12_qqHll_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11512: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11513{
11514 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11515 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with a class whose parent is not NPbase");
11516
11517}
11518
11520{
11521 //-- Production:
11522 double weight = 1.0; //If normalized to the SM
11523 double muProd = myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s);
11524 double muProd1 = muProd -1.0;
11525 double muProd2 = 0.0;
11526
11527 //-- Decay:
11528 double BrHXXRatio = 1.0;
11529 double dBrHXXRatio1 = 0.0;
11530 double dBrHXXRatio2 = 0.0;
11531 if (fstate==0){
11532 // Use for Cross-section [pb] with no Higgs-boson decay
11533 weight = 0.00126 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11534 } else if (fstate == 1){
11535 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11536 dBrHXXRatio1 = BrHXXRatio - 1.0;
11537 dBrHXXRatio2 = 0.0;
11538 } else if (fstate == 2){
11539 BrHXXRatio = (myNPbase->BrHgagaRatio());
11540 dBrHXXRatio1 = BrHXXRatio - 1.0;
11541 dBrHXXRatio2 = 0.0;
11542 } else if (fstate == 3){
11543 BrHXXRatio = (myNPbase->BrHbbRatio());
11544 dBrHXXRatio1 = BrHXXRatio - 1.0;
11545 dBrHXXRatio2 = 0.0;
11546 } else if (fstate == 4){
11547 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11548 dBrHXXRatio1 = BrHXXRatio - 1.0;
11549 dBrHXXRatio2 = 0.0;
11550 } else if (fstate == 5){
11551 BrHXXRatio = (myNPbase->BrHtautauRatio());
11552 dBrHXXRatio1 = BrHXXRatio - 1.0;
11553 dBrHXXRatio2 = 0.0;
11554 } else if (fstate == 6){
11555 BrHXXRatio = (myNPbase->BrHWWRatio());
11556 dBrHXXRatio1 = BrHXXRatio - 1.0;
11557 dBrHXXRatio2 = 0.0;
11558 } else if (fstate == 7){
11559 BrHXXRatio = (myNPbase->BrHZZRatio());
11560 dBrHXXRatio1 = BrHXXRatio - 1.0;
11561 dBrHXXRatio2 = 0.0;
11562 } else {
11563 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with invalid argument for final state in fstate_i");
11564 }
11565
11566 //-- Production x Decay:
11567 if ((this->getModel()).isModelLinearized()){
11568 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11569 } else if((this->getModel()).isModelNPquadratic()){
11570 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11571 } else {
11572 return weight*(muProd)*(BrHXXRatio);
11573 }
11574
11575
11576}
11577
11578// -----------------------------------------------------------------------------
11579
11580//AG:STXS2024
11581STXS12_qqHll_pTV150_Inf::STXS12_qqHll_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11582: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11583{
11584 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11585 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with a class whose parent is not NPbase");
11586
11587}
11588
11590{
11591 //-- Production:
11592 double weight = 1.0; //If normalized to the SM
11593 //Since adding bins, include partial weigths of SM_predictions
11594 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11595 double muProd = (0.0147*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s))
11598 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)) )/(0.0147+0.01683+0.00715+0.00126);
11599 double muProd1 = muProd-1.0;
11600 double muProd2 = 0.0;
11601
11602 //-- Decay:
11603 double BrHXXRatio = 1.0;
11604 double dBrHXXRatio1 = 0.0;
11605 double dBrHXXRatio2 = 0.0;
11606 if (fstate==0){
11607 weight = (0.0147+0.01683+0.00715+0.00126);
11608 } else if (fstate == 1){
11609 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11610 dBrHXXRatio1 = BrHXXRatio - 1.0;
11611 dBrHXXRatio2 = 0.0;
11612 } else if (fstate == 2){
11613 BrHXXRatio = (myNPbase->BrHgagaRatio());
11614 dBrHXXRatio1 = BrHXXRatio - 1.0;
11615 dBrHXXRatio2 = 0.0;
11616 } else if (fstate == 3){
11617 BrHXXRatio = (myNPbase->BrHbbRatio());
11618 dBrHXXRatio1 = BrHXXRatio - 1.0;
11619 dBrHXXRatio2 = 0.0;
11620 } else if (fstate == 4){
11621 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11622 dBrHXXRatio1 = BrHXXRatio - 1.0;
11623 dBrHXXRatio2 = 0.0;
11624 } else if (fstate == 5){
11625 BrHXXRatio = (myNPbase->BrHtautauRatio());
11626 dBrHXXRatio1 = BrHXXRatio - 1.0;
11627 dBrHXXRatio2 = 0.0;
11628 } else if (fstate == 6){
11629 BrHXXRatio = (myNPbase->BrHWWRatio());
11630 dBrHXXRatio1 = BrHXXRatio - 1.0;
11631 dBrHXXRatio2 = 0.0;
11632 } else if (fstate == 7){
11633 BrHXXRatio = (myNPbase->BrHZZRatio());
11634 dBrHXXRatio1 = BrHXXRatio - 1.0;
11635 dBrHXXRatio2 = 0.0;
11636 } else {
11637 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with invalid argument for final state in fstate_i");
11638 }
11639
11640 //-- Production x Decay:
11641 if ((this->getModel()).isModelLinearized()){
11642 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11643 } else if((this->getModel()).isModelNPquadratic()){
11644 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11645 } else {
11646 return weight*(muProd)*(BrHXXRatio);
11647 }
11648
11649
11650}
11651
11652
11653
11654
11655
11656
11657
11658
11659//VM:STXS2025
11660STXS12_qqHll::STXS12_qqHll(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11661: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11662{
11663 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11664 throw std::runtime_error("STXS12_qqHll called with a class whose parent is not NPbase");
11665
11666}
11667
11669{
11670 //-- Production:
11671 double weight = 1.0; //If normalized to the SM
11672 //Since adding bins, include partial weigths of SM_predictions
11673 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11674 double muProd = (0.19845*(myNPbase->STXS12_qqHll_pTV0_150(sqrt_s))
11679 )/(0.19845+0.0147+0.01683+0.00715+0.00126);
11680 double muProd1 = muProd - 1.0;
11681 double muProd2 = 0.0;
11682
11683 //-- Decay:
11684 double BrHXXRatio = 1.0;
11685 double dBrHXXRatio1 = 0.0;
11686 double dBrHXXRatio2 = 0.0;
11687 if (fstate==0){
11688 weight = (0.19845+0.0147+0.01683+0.00715+0.00126);
11689 } else if (fstate == 1){
11690 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11691 dBrHXXRatio1 = BrHXXRatio - 1.0;
11692 dBrHXXRatio2 = 0.0;
11693 } else if (fstate == 2){
11694 BrHXXRatio = (myNPbase->BrHgagaRatio());
11695 dBrHXXRatio1 = BrHXXRatio - 1.0;
11696 dBrHXXRatio2 = 0.0;
11697 } else if (fstate == 3){
11698 BrHXXRatio = (myNPbase->BrHbbRatio());
11699 dBrHXXRatio1 = BrHXXRatio - 1.0;
11700 dBrHXXRatio2 = 0.0;
11701 } else if (fstate == 4){
11702 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11703 dBrHXXRatio1 = BrHXXRatio - 1.0;
11704 dBrHXXRatio2 = 0.0;
11705 } else if (fstate == 5){
11706 BrHXXRatio = (myNPbase->BrHtautauRatio());
11707 dBrHXXRatio1 = BrHXXRatio - 1.0;
11708 dBrHXXRatio2 = 0.0;
11709 } else if (fstate == 6){
11710 BrHXXRatio = (myNPbase->BrHWWRatio());
11711 dBrHXXRatio1 = BrHXXRatio - 1.0;
11712 dBrHXXRatio2 = 0.0;
11713 } else if (fstate == 7){
11714 BrHXXRatio = (myNPbase->BrHZZRatio());
11715 dBrHXXRatio1 = BrHXXRatio - 1.0;
11716 dBrHXXRatio2 = 0.0;
11717 } else {
11718 throw std::runtime_error("STXS12_qqHll called with invalid argument for final state in fstate_i");
11719 }
11720
11721 //-- Production x Decay:
11722 if ((this->getModel()).isModelLinearized()){
11723 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11724 } else if((this->getModel()).isModelNPquadratic()){
11725 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11726 } else {
11727 return weight*(muProd)*(BrHXXRatio);
11728 }
11729
11730
11731}
11732
11733
11734
11735
11736// -----------------------------------------------------------------------------
11737
11738//AG:STXS2024
11739STXS12_VHlep::STXS12_VHlep(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11740: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11741{
11742 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11743 throw std::runtime_error("STXS12_VHlep called with a class whose parent is not NPbase");
11744
11745}
11746
11748{
11749 //-- Production:
11750 double weight = 1.0; //If normalized to the SM
11751 //Since adding bins, include partial weigths of SM_predictions
11752 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11753 double muProd = ( 0.71256*myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)
11763 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934
11764 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
11765
11766 double muProd1 = muProd - 1.0;
11767 double muProd2 = 0.0;
11768
11769 //-- Decay:
11770 double BrHXXRatio = 1.0;
11771 double dBrHXXRatio1 = 0.0;
11772 double dBrHXXRatio2 = 0.0;
11773 if (fstate==0){
11774 weight = (0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934
11775 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
11776 } else if (fstate == 1){
11777 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11778 dBrHXXRatio1 = BrHXXRatio - 1.0;
11779 dBrHXXRatio2 = 0.0;
11780 } else if (fstate == 2){
11781 BrHXXRatio = (myNPbase->BrHgagaRatio());
11782 dBrHXXRatio1 = BrHXXRatio - 1.0;
11783 dBrHXXRatio2 = 0.0;
11784 } else if (fstate == 3){
11785 BrHXXRatio = (myNPbase->BrHbbRatio());
11786 dBrHXXRatio1 = BrHXXRatio - 1.0;
11787 dBrHXXRatio2 = 0.0;
11788 } else if (fstate == 4){
11789 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11790 dBrHXXRatio1 = BrHXXRatio - 1.0;
11791 dBrHXXRatio2 = 0.0;
11792 } else if (fstate == 5){
11793 BrHXXRatio = (myNPbase->BrHtautauRatio());
11794 dBrHXXRatio1 = BrHXXRatio - 1.0;
11795 dBrHXXRatio2 = 0.0;
11796 } else if (fstate == 6){
11797 BrHXXRatio = (myNPbase->BrHWWRatio());
11798 dBrHXXRatio1 = BrHXXRatio - 1.0;
11799 dBrHXXRatio2 = 0.0;
11800 } else if (fstate == 7){
11801 BrHXXRatio = (myNPbase->BrHZZRatio());
11802 dBrHXXRatio1 = BrHXXRatio - 1.0;
11803 dBrHXXRatio2 = 0.0;
11804 } else {
11805 throw std::runtime_error("STXS12_VHlep called with invalid argument for final state in fstate_i");
11806 }
11807
11808 //-- Production x Decay:
11809 if ((this->getModel()).isModelLinearized()){
11810 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11811 } else if((this->getModel()).isModelNPquadratic()){
11812 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11813 } else {
11814 return weight*(muProd)*(BrHXXRatio);
11815 }
11816
11817
11818}
11819
11820// -----------------------------------------------------------------------------
11821
11822
11823
11824
11825
11826
11827//VM:STXS2025
11828STXS12_VHlep_pTV0_150::STXS12_VHlep_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //VM:added
11829: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11830{
11831 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11832 throw std::runtime_error("STXS12_VHlep_pTV0_150 called with a class whose parent is not NPbase");
11833
11834}
11835
11837{
11838 //-- Production:
11839 double weight = 1.0; //If normalized to the SM
11840 //Since adding bins, include partial weigths of SM_predictions
11841 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11842 double muProd = ( 0.71256*myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)
11845 )
11846 /(0.71256 + 0.06739 + 0.07934);
11847 double muProd1 = muProd - 1.0;
11848 double muProd2 = 0.0;
11849
11850 //-- Decay:
11851 double BrHXXRatio = 1.0;
11852 double dBrHXXRatio1 = 0.0;
11853 double dBrHXXRatio2 = 0.0;
11854 if (fstate==0){
11855 weight = 1.0;
11856 } else if (fstate == 1){
11857 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11858 dBrHXXRatio1 = BrHXXRatio - 1.0;
11859 dBrHXXRatio2 = 0.0;
11860 } else if (fstate == 2){
11861 BrHXXRatio = (myNPbase->BrHgagaRatio());
11862 dBrHXXRatio1 = BrHXXRatio - 1.0;
11863 dBrHXXRatio2 = 0.0;
11864 } else if (fstate == 3){
11865 BrHXXRatio = (myNPbase->BrHbbRatio());
11866 dBrHXXRatio1 = BrHXXRatio - 1.0;
11867 dBrHXXRatio2 = 0.0;
11868 } else if (fstate == 4){
11869 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11870 dBrHXXRatio1 = BrHXXRatio - 1.0;
11871 dBrHXXRatio2 = 0.0;
11872 } else if (fstate == 5){
11873 BrHXXRatio = (myNPbase->BrHtautauRatio());
11874 dBrHXXRatio1 = BrHXXRatio - 1.0;
11875 dBrHXXRatio2 = 0.0;
11876 } else if (fstate == 6){
11877 BrHXXRatio = (myNPbase->BrHWWRatio());
11878 dBrHXXRatio1 = BrHXXRatio - 1.0;
11879 dBrHXXRatio2 = 0.0;
11880 } else if (fstate == 7){
11881 BrHXXRatio = (myNPbase->BrHZZRatio());
11882 dBrHXXRatio1 = BrHXXRatio - 1.0;
11883 dBrHXXRatio2 = 0.0;
11884 } else {
11885 throw std::runtime_error("STXS12_VHlep_pTV0_150 called with invalid argument for final state in fstate_i");
11886 }
11887
11888 //-- Production x Decay:
11889 if ((this->getModel()).isModelLinearized()){
11890 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11891 } else if((this->getModel()).isModelNPquadratic()){
11892 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11893 } else {
11894 return weight*(muProd)*(BrHXXRatio);
11895 }
11896
11897
11898}
11899
11900// -----------------------------------------------------------------------------
11901
11902
11903
11904
11905
11906//VM:STXS2024
11907STXS12_VHlep_pTV150_Inf::STXS12_VHlep_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //VM:added
11908: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11909{
11910 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11911 throw std::runtime_error("STXS12_VHlep_pTV150_Inf called with a class whose parent is not NPbase");
11912
11913}
11914
11916{
11917 //-- Production:
11918 double weight = 1.0; //If normalized to the SM
11919 //Since adding bins, include partial weigths of SM_predictions
11920 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11921 double muProd = (0.03943*myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s)
11928 /(0.03943 + 0.01127 + 0.00339 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
11929 double muProd1 = (muProd - 1.0);
11930 double muProd2 = 0.0;
11931
11932 //-- Decay:
11933 double BrHXXRatio = 1.0;
11934 double dBrHXXRatio1 = 0.0;
11935 double dBrHXXRatio2 = 0.0;
11936 if (fstate==0){
11937 weight = (0.03943 + 0.01127 + 0.00339 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
11938 } else if (fstate == 1){
11939 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11940 dBrHXXRatio1 = BrHXXRatio - 1.0;
11941 dBrHXXRatio2 = 0.0;
11942 } else if (fstate == 2){
11943 BrHXXRatio = (myNPbase->BrHgagaRatio());
11944 dBrHXXRatio1 = BrHXXRatio - 1.0;
11945 dBrHXXRatio2 = 0.0;
11946 } else if (fstate == 3){
11947 BrHXXRatio = (myNPbase->BrHbbRatio());
11948 dBrHXXRatio1 = BrHXXRatio - 1.0;
11949 dBrHXXRatio2 = 0.0;
11950 } else if (fstate == 4){
11951 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11952 dBrHXXRatio1 = BrHXXRatio - 1.0;
11953 dBrHXXRatio2 = 0.0;
11954 } else if (fstate == 5){
11955 BrHXXRatio = (myNPbase->BrHtautauRatio());
11956 dBrHXXRatio1 = BrHXXRatio - 1.0;
11957 dBrHXXRatio2 = 0.0;
11958 } else if (fstate == 6){
11959 BrHXXRatio = (myNPbase->BrHWWRatio());
11960 dBrHXXRatio1 = BrHXXRatio - 1.0;
11961 dBrHXXRatio2 = 0.0;
11962 } else if (fstate == 7){
11963 BrHXXRatio = (myNPbase->BrHZZRatio());
11964 dBrHXXRatio1 = BrHXXRatio - 1.0;
11965 dBrHXXRatio2 = 0.0;
11966 } else {
11967 throw std::runtime_error("STXS12_VHlep_pTV150_Inf called with invalid argument for final state in fstate_i");
11968 }
11969
11970 //-- Production x Decay:
11971 if ((this->getModel()).isModelLinearized()){
11972 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11973 } else if((this->getModel()).isModelNPquadratic()){
11974 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11975 } else {
11976 return weight*(muProd)*(BrHXXRatio);
11977 }
11978
11979
11980}
11981
11982// -----------------------------------------------------------------------------
11983
11984
11985
11986
11987
11988
11989//AG:STXS2024
11990STXS12_ttH_pTH0_60::STXS12_ttH_pTH0_60(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11991: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11992{
11993 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11994 throw std::runtime_error("STXS12_ttH_pTH0_60 called with a class whose parent is not NPbase");
11995
11996}
11997
11999{
12000 //-- Production:
12001 double weight = 1.0; //If normalized to the SM
12002 double muProd = myNPbase->STXS12_ttH_pTH0_60(sqrt_s) ;
12003 double muProd1 = muProd -1.0;
12004 double muProd2 = 0.0;
12005
12006 //-- Decay:
12007 double BrHXXRatio = 1.0;
12008 double dBrHXXRatio1 = 0.0;
12009 double dBrHXXRatio2 = 0.0;
12010 if (fstate==0){
12011 // Use for Cross-section [pb] with no Higgs-boson decay
12012 weight = 0.11821; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12013 } else if (fstate == 1){
12014 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12015 dBrHXXRatio1 = BrHXXRatio - 1.0;
12016 dBrHXXRatio2 = 0.0;
12017 } else if (fstate == 2){
12018 BrHXXRatio = (myNPbase->BrHgagaRatio());
12019 dBrHXXRatio1 = BrHXXRatio - 1.0;
12020 dBrHXXRatio2 = 0.0;
12021 } else if (fstate == 3){
12022 BrHXXRatio = (myNPbase->BrHbbRatio());
12023 dBrHXXRatio1 = BrHXXRatio - 1.0;
12024 dBrHXXRatio2 = 0.0;
12025 } else if (fstate == 4){
12026 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12027 dBrHXXRatio1 = BrHXXRatio - 1.0;
12028 dBrHXXRatio2 = 0.0;
12029 } else {
12030 throw std::runtime_error("STXS12_ttH_pTH0_60 called with invalid argument for final state in fstate_i");
12031 }
12032
12033 //-- Production x Decay:
12034 if ((this->getModel()).isModelLinearized()){
12035 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12036 } else if((this->getModel()).isModelNPquadratic()){
12037 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12038 } else {
12039 return weight*(muProd)*(BrHXXRatio);
12040 }
12041
12042
12043}
12044
12045// -----------------------------------------------------------------------------
12046
12047//AG:STXS2024
12048STXS12_ttH_pTH60_120::STXS12_ttH_pTH60_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
12049: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12050{
12051 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12052 throw std::runtime_error("STXS12_ttH_pTH60_120 called with a class whose parent is not NPbase");
12053
12054}
12055
12057{
12058 //-- Production:
12059 double weight = 1.0; //If normalized to the SM
12060 double muProd = myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ;
12061 double muProd1 = muProd -1.0;
12062 double muProd2 = 0.0;
12063
12064 //-- Decay:
12065 double BrHXXRatio = 1.0;
12066 double dBrHXXRatio1 = 0.0;
12067 double dBrHXXRatio2 = 0.0;
12068 if (fstate==0){
12069 // Use for Cross-section [pb] with no Higgs-boson decay
12070 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12071 } else if (fstate == 1){
12072 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12073 dBrHXXRatio1 = BrHXXRatio - 1.0;
12074 dBrHXXRatio2 = 0.0;
12075 } else if (fstate == 2){
12076 BrHXXRatio = (myNPbase->BrHgagaRatio());
12077 dBrHXXRatio1 = BrHXXRatio - 1.0;
12078 dBrHXXRatio2 = 0.0;
12079 } else if (fstate == 3){
12080 BrHXXRatio = (myNPbase->BrHbbRatio());
12081 dBrHXXRatio1 = BrHXXRatio - 1.0;
12082 dBrHXXRatio2 = 0.0;
12083 } else if (fstate == 4){
12084 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12085 dBrHXXRatio1 = BrHXXRatio - 1.0;
12086 dBrHXXRatio2 = 0.0;
12087 } else {
12088 throw std::runtime_error("STXS12_ttH_pTH60_120 called with invalid argument for final state in fstate_i");
12089 }
12090
12091 //-- Production x Decay:
12092 if ((this->getModel()).isModelLinearized()){
12093 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12094 } else if((this->getModel()).isModelNPquadratic()){
12095 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12096 } else {
12097 return weight*(muProd)*(BrHXXRatio);
12098 }
12099
12100}
12101
12102// -----------------------------------------------------------------------------
12103
12104//AG:STXS2024
12105STXS12_ttH_pTH0_120::STXS12_ttH_pTH0_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
12106: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12107{
12108 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12109 throw std::runtime_error("STXS12_ttH_pTH0_120 called with a class whose parent is not NPbase");
12110
12111}
12112
12114{
12115 //-- Production:
12116 double weight = 1.0; //If normalized to the SM
12117 //Since adding bins, include partial weigths of SM_predictions
12118 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
12119 double muProd = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) )
12120 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ) )/(0.11821+0.17813);
12121 double muProd1 = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) -1.0)
12122 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0 ) )/(0.11821+0.17813);;
12123 double muProd2 = 0.0;
12124
12125 //-- Decay:
12126 double BrHXXRatio = 1.0;
12127 double dBrHXXRatio1 = 0.0;
12128 double dBrHXXRatio2 = 0.0;
12129 if (fstate==0){
12130 // Use for Cross-section [pb] with no Higgs-boson decay
12131 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12132 } else if (fstate == 1){
12133 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12134 dBrHXXRatio1 = BrHXXRatio - 1.0;
12135 dBrHXXRatio2 = 0.0;
12136 } else if (fstate == 2){
12137 BrHXXRatio = (myNPbase->BrHgagaRatio());
12138 dBrHXXRatio1 = BrHXXRatio - 1.0;
12139 dBrHXXRatio2 = 0.0;
12140 } else if (fstate == 3){
12141 BrHXXRatio = (myNPbase->BrHbbRatio());
12142 dBrHXXRatio1 = BrHXXRatio - 1.0;
12143 dBrHXXRatio2 = 0.0;
12144 } else if (fstate == 4){
12145 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12146 dBrHXXRatio1 = BrHXXRatio - 1.0;
12147 dBrHXXRatio2 = 0.0;
12148 } else {
12149 throw std::runtime_error("STXS12_ttH_pTH0_120 called with invalid argument for final state in fstate_i");
12150 }
12151
12152 //-- Production x Decay:
12153 if ((this->getModel()).isModelLinearized()){
12154 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12155 } else if((this->getModel()).isModelNPquadratic()){
12156 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12157 } else {
12158 return weight*(muProd)*(BrHXXRatio);
12159 }
12160
12161}
12162
12163// -----------------------------------------------------------------------------
12164
12165//AG:STXS2024
12166STXS12_ttH_pTH120_200::STXS12_ttH_pTH120_200(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
12167: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12168{
12169 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12170 throw std::runtime_error("STXS12_ttH_pTH120_200 called with a class whose parent is not NPbase");
12171
12172}
12173
12175{
12176 //-- Production:
12177 double weight = 1.0; //If normalized to the SM
12178 double muProd = myNPbase->STXS12_ttH_pTH120_200(sqrt_s) ;
12179 double muProd1 = muProd -1.0;
12180 double muProd2 = 0.0;
12181
12182 //-- Decay:
12183 double BrHXXRatio = 1.0;
12184 double dBrHXXRatio1 = 0.0;
12185 double dBrHXXRatio2 = 0.0;
12186 if (fstate==0){
12187 // Use for Cross-section [pb] with no Higgs-boson decay
12188 weight = 0.12647; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12189 } else if (fstate == 1){
12190 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12191 dBrHXXRatio1 = BrHXXRatio - 1.0;
12192 dBrHXXRatio2 = 0.0;
12193 } else if (fstate == 2){
12194 BrHXXRatio = (myNPbase->BrHgagaRatio());
12195 dBrHXXRatio1 = BrHXXRatio - 1.0;
12196 dBrHXXRatio2 = 0.0;
12197 } else if (fstate == 3){
12198 BrHXXRatio = (myNPbase->BrHbbRatio());
12199 dBrHXXRatio1 = BrHXXRatio - 1.0;
12200 dBrHXXRatio2 = 0.0;
12201 } else if (fstate == 4){
12202 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12203 dBrHXXRatio1 = BrHXXRatio - 1.0;
12204 dBrHXXRatio2 = 0.0;
12205 } else {
12206 throw std::runtime_error("STXS12_ttH_pTH120_200 called with invalid argument for final state in fstate_i");
12207 }
12208
12209 //-- Production x Decay:
12210 if ((this->getModel()).isModelLinearized()){
12211 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12212 } else if((this->getModel()).isModelNPquadratic()){
12213 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12214 } else {
12215 return weight*(muProd)*(BrHXXRatio);
12216 }
12217
12218}
12219
12220// -----------------------------------------------------------------------------
12221
12222//AG:STXS2024
12223STXS12_ttH_pTH200_300::STXS12_ttH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
12224: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12225{
12226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12227 throw std::runtime_error("STXS12_ttH_pTH200_300 called with a class whose parent is not NPbase");
12228
12229}
12230
12232{
12233 //-- Production:
12234 double weight = 1.0; //If normalized to the SM
12235 double muProd = myNPbase->STXS12_ttH_pTH200_300(sqrt_s) ;
12236 double muProd1 = muProd -1.0;
12237 double muProd2 = 0.0;
12238
12239 //-- Decay:
12240 double BrHXXRatio = 1.0;
12241 double dBrHXXRatio1 = 0.0;
12242 double dBrHXXRatio2 = 0.0;
12243 if (fstate==0){
12244 // Use for Cross-section [pb] with no Higgs-boson decay
12245 weight = 0.05263; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12246 } else if (fstate == 1){
12247 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12248 dBrHXXRatio1 = BrHXXRatio - 1.0;
12249 dBrHXXRatio2 = 0.0;
12250 } else if (fstate == 2){
12251 BrHXXRatio = (myNPbase->BrHgagaRatio());
12252 dBrHXXRatio1 = BrHXXRatio - 1.0;
12253 dBrHXXRatio2 = 0.0;
12254 } else if (fstate == 3){
12255 BrHXXRatio = (myNPbase->BrHbbRatio());
12256 dBrHXXRatio1 = BrHXXRatio - 1.0;
12257 dBrHXXRatio2 = 0.0;
12258 } else if (fstate == 4){
12259 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12260 dBrHXXRatio1 = BrHXXRatio - 1.0;
12261 dBrHXXRatio2 = 0.0;
12262 } else {
12263 throw std::runtime_error("STXS12_ttH_pTH200_300 called with invalid argument for final state in fstate_i");
12264 }
12265
12266 //-- Production x Decay:
12267 if ((this->getModel()).isModelLinearized()){
12268 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12269 } else if((this->getModel()).isModelNPquadratic()){
12270 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12271 } else {
12272 return weight*(muProd)*(BrHXXRatio);
12273 }
12274
12275}
12276
12277// -----------------------------------------------------------------------------
12278
12279STXS12_ttH_pTH300_Inf::STXS12_ttH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
12280: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12281{
12282 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12283 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with a class whose parent is not NPbase");
12284
12285}
12286
12288{
12289 //VM: Modified to take the thinner bins
12290 //-- Production:
12291 double weight = 1.0; //If normalized to the SM
12292 //double muProd = myNPbase->STXS12_ttH_pTH300_Inf(sqrt_s) ;
12293 double muProd = (0.01903*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s))
12295 )/(0.01903+0.00538);
12296 double muProd1 = muProd -1.0;
12297 double muProd2 = 0.0;
12298
12299 //-- Decay:
12300 double BrHXXRatio = 1.0;
12301 double dBrHXXRatio1 = 0.0;
12302 double dBrHXXRatio2 = 0.0;
12303 if (fstate==0){
12304 // Use for Cross-section [pb] with no Higgs-boson decay
12305 weight = (0.01903+0.00538); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12306 } else if (fstate == 1){
12307 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12308 dBrHXXRatio1 = BrHXXRatio - 1.0;
12309 dBrHXXRatio2 = 0.0;
12310 } else if (fstate == 2){
12311 BrHXXRatio = (myNPbase->BrHgagaRatio());
12312 dBrHXXRatio1 = BrHXXRatio - 1.0;
12313 dBrHXXRatio2 = 0.0;
12314 } else if (fstate == 3){
12315 BrHXXRatio = (myNPbase->BrHbbRatio());
12316 dBrHXXRatio1 = BrHXXRatio - 1.0;
12317 dBrHXXRatio2 = 0.0;
12318 } else if (fstate == 4){
12319 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12320 dBrHXXRatio1 = BrHXXRatio - 1.0;
12321 dBrHXXRatio2 = 0.0;
12322 } else {
12323 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with invalid argument for final state in fstate_i");
12324 }
12325
12326 //-- Production x Decay:
12327 if ((this->getModel()).isModelLinearized()){
12328 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12329 } else if((this->getModel()).isModelNPquadratic()){
12330 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12331 } else {
12332 return weight*(muProd)*(BrHXXRatio);
12333 }
12334
12335
12336}
12337
12338// -----------------------------------------------------------------------------
12339
12340//AG:STXS2024
12341STXS12_ttH_pTH300_450::STXS12_ttH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
12342: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12343{
12344 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12345 throw std::runtime_error("STXS12_ttH_pTH300_450 called with a class whose parent is not NPbase");
12346
12347}
12348
12350{
12351 //-- Production:
12352 double weight = 1.0; //If normalized to the SM
12353 double muProd = myNPbase->STXS12_ttH_pTH300_450(sqrt_s);
12354 double muProd1 = muProd -1.0;
12355 double muProd2 = 0.0;
12356
12357 //-- Decay:
12358 double BrHXXRatio = 1.0;
12359 double dBrHXXRatio1 = 0.0;
12360 double dBrHXXRatio2 = 0.0;
12361 if (fstate==0){
12362 // Use for Cross-section [pb] with no Higgs-boson decay
12363 weight = 0.01903; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12364 } else if (fstate == 1){
12365 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12366 dBrHXXRatio1 = BrHXXRatio - 1.0;
12367 dBrHXXRatio2 = 0.0;
12368 } else if (fstate == 2){
12369 BrHXXRatio = (myNPbase->BrHgagaRatio());
12370 dBrHXXRatio1 = BrHXXRatio - 1.0;
12371 dBrHXXRatio2 = 0.0;
12372 } else if (fstate == 3){
12373 BrHXXRatio = (myNPbase->BrHbbRatio());
12374 dBrHXXRatio1 = BrHXXRatio - 1.0;
12375 dBrHXXRatio2 = 0.0;
12376 } else if (fstate == 4){
12377 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12378 dBrHXXRatio1 = BrHXXRatio - 1.0;
12379 dBrHXXRatio2 = 0.0;
12380 } else if (fstate == 5){
12381 BrHXXRatio = (myNPbase->BrHtautauRatio());
12382 dBrHXXRatio1 = BrHXXRatio - 1.0;
12383 dBrHXXRatio2 = 0.0;
12384 } else {
12385 throw std::runtime_error("STXS12_ttH_pTH300_450 called with invalid argument for final state in fstate_i");
12386 }
12387
12388 //-- Production x Decay:
12389 if ((this->getModel()).isModelLinearized()){
12390 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12391 } else if((this->getModel()).isModelNPquadratic()){
12392 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12393 } else {
12394 return weight*(muProd)*(BrHXXRatio);
12395 }
12396
12397}
12398// -----------------------------------------------------------------------------
12399
12400//AG:STXS2024
12401STXS12_ttH_pTH450_Inf::STXS12_ttH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
12402: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12403{
12404 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12405 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with a class whose parent is not NPbase");
12406
12407}
12408
12410{
12411 //-- Production:
12412 double weight = 1.0; //If normalized to the SM
12413 double muProd = myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s);
12414 double muProd1 = muProd -1.0;
12415 double muProd2 = 0.0;
12416
12417 //-- Decay:
12418 double BrHXXRatio = 1.0;
12419 double dBrHXXRatio1 = 0.0;
12420 double dBrHXXRatio2 = 0.0;
12421 if (fstate==0){
12422 // Use for Cross-section [pb] with no Higgs-boson decay
12423 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12424 } else if (fstate == 1){
12425 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12426 dBrHXXRatio1 = BrHXXRatio - 1.0;
12427 dBrHXXRatio2 = 0.0;
12428 } else if (fstate == 2){
12429 BrHXXRatio = (myNPbase->BrHgagaRatio());
12430 dBrHXXRatio1 = BrHXXRatio - 1.0;
12431 dBrHXXRatio2 = 0.0;
12432 } else if (fstate == 3){
12433 BrHXXRatio = (myNPbase->BrHbbRatio());
12434 dBrHXXRatio1 = BrHXXRatio - 1.0;
12435 dBrHXXRatio2 = 0.0;
12436 } else if (fstate == 4){
12437 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12438 dBrHXXRatio1 = BrHXXRatio - 1.0;
12439 dBrHXXRatio2 = 0.0;
12440 } else if (fstate == 5){
12441 BrHXXRatio = (myNPbase->BrHtautauRatio());
12442 dBrHXXRatio1 = BrHXXRatio - 1.0;
12443 dBrHXXRatio2 = 0.0;
12444 } else {
12445 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with invalid argument for final state in fstate_i");
12446 }
12447
12448 //-- Production x Decay:
12449 if ((this->getModel()).isModelLinearized()){
12450 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12451 } else if((this->getModel()).isModelNPquadratic()){
12452 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12453 } else {
12454 return weight*(muProd)*(BrHXXRatio);
12455 }
12456
12457}
12458
12459// -----------------------------------------------------------------------------
12460
12461//AG:STXS2024
12462STXS12_ttH_pTH300_Inf_add::STXS12_ttH_pTH300_Inf_add(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
12463: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12464{
12465 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12466 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with a class whose parent is not NPbase");
12467
12468}
12469
12471{
12472 //-- Production:
12473 double weight = 1.0; //If normalized to the SM
12474 //Since adding bins, include partial weigths of SM_predictions
12475 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
12476 double muProd = (0.01903*myNPbase->STXS12_ttH_pTH300_450(sqrt_s)
12477 + 0.00538*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)) / (0.01903+0.00538);
12478 double muProd1 = muProd - 1.0;
12479 double muProd2 = 0.0;
12480
12481 //-- Decay:
12482 double BrHXXRatio = 1.0;
12483 double dBrHXXRatio1 = 0.0;
12484 double dBrHXXRatio2 = 0.0;
12485 if (fstate==0){
12486 // Use for Cross-section [pb] with no Higgs-boson decay
12487 weight = (0.01903+0.00538); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12488 } else if (fstate == 1){
12489 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12490 dBrHXXRatio1 = BrHXXRatio - 1.0;
12491 dBrHXXRatio2 = 0.0;
12492 } else if (fstate == 2){
12493 BrHXXRatio = (myNPbase->BrHgagaRatio());
12494 dBrHXXRatio1 = BrHXXRatio - 1.0;
12495 dBrHXXRatio2 = 0.0;
12496 } else if (fstate == 3){
12497 BrHXXRatio = (myNPbase->BrHbbRatio());
12498 dBrHXXRatio1 = BrHXXRatio - 1.0;
12499 dBrHXXRatio2 = 0.0;
12500 } else if (fstate == 4){
12501 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12502 dBrHXXRatio1 = BrHXXRatio - 1.0;
12503 dBrHXXRatio2 = 0.0;
12504 } else if (fstate == 5){
12505 BrHXXRatio = (myNPbase->BrHtautauRatio());
12506 dBrHXXRatio1 = BrHXXRatio - 1.0;
12507 dBrHXXRatio2 = 0.0;
12508 } else {
12509 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with invalid argument for final state in fstate_i");
12510 }
12511
12512 //-- Production x Decay:
12513 if ((this->getModel()).isModelLinearized()){
12514 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12515 } else if((this->getModel()).isModelNPquadratic()){
12516 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12517 } else {
12518 return weight*(muProd)*(BrHXXRatio);
12519 }
12520
12521}
12522
12523// -----------------------------------------------------------------------------
12524
12525//AG:STXS2024
12526STXS12_ttH::STXS12_ttH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
12527: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12528{
12529 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12530 throw std::runtime_error("STXS12_ttH called with a class whose parent is not NPbase");
12531
12532}
12533
12535{
12536 //-- Production:
12537 double weight = 1.0; //If normalized to the SM
12538 //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12539 //Since adding bins, include partial weigths (SM_predictions)
12540 double muProd = ( 0.09779*myNPbase->STXS12_ttH_pTH0_60(sqrt_s)
12545 + 0.00060*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
12546 double muProd1 = ( 0.09779*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s)-1.0)
12547 + 0.13884*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0)
12548 + 0.05439*(myNPbase->STXS12_ttH_pTH120_200(sqrt_s)-1.0)
12549 + 0.05303*(myNPbase->STXS12_ttH_pTH200_300(sqrt_s)-1.0)
12550 + 0.00498*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
12551 + 0.00060*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
12552 double muProd2 = 0.0;
12553
12554 //-- Decay:
12555 double BrHXXRatio = 1.0;
12556 double dBrHXXRatio1 = 0.0;
12557 double dBrHXXRatio2 = 0.0;
12558 if (fstate==0){
12559 weight = (0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
12560 } else if (fstate == 1){
12561 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12562 dBrHXXRatio1 = BrHXXRatio - 1.0;
12563 dBrHXXRatio2 = 0.0;
12564 } else if (fstate == 2){
12565 BrHXXRatio = (myNPbase->BrHgagaRatio());
12566 dBrHXXRatio1 = BrHXXRatio - 1.0;
12567 dBrHXXRatio2 = 0.0;
12568 } else if (fstate == 3){
12569 BrHXXRatio = (myNPbase->BrHbbRatio());
12570 dBrHXXRatio1 = BrHXXRatio - 1.0;
12571 dBrHXXRatio2 = 0.0;
12572 } else if (fstate == 4){
12573 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12574 dBrHXXRatio1 = BrHXXRatio - 1.0;
12575 dBrHXXRatio2 = 0.0;
12576 } else if (fstate == 5){
12577 BrHXXRatio = (myNPbase->BrHtautauRatio());
12578 dBrHXXRatio1 = BrHXXRatio - 1.0;
12579 dBrHXXRatio2 = 0.0;
12580 } else if (fstate == 6){
12581 BrHXXRatio = (myNPbase->BrHWWRatio());
12582 dBrHXXRatio1 = BrHXXRatio - 1.0;
12583 dBrHXXRatio2 = 0.0;
12584 } else if (fstate == 7){
12585 BrHXXRatio = (myNPbase->BrHZZRatio());
12586 dBrHXXRatio1 = BrHXXRatio - 1.0;
12587 dBrHXXRatio2 = 0.0;
12588 } else {
12589 throw std::runtime_error("STXS12_ttH called with invalid argument for final state in fstate_i");
12590 }
12591
12592 //-- Production x Decay:
12593 if ((this->getModel()).isModelLinearized()){
12594 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12595 } else if((this->getModel()).isModelNPquadratic()){
12596 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12597 } else {
12598 return weight*(muProd)*(BrHXXRatio);
12599 }
12600
12601}
12602
12603// -----------------------------------------------------------------------------
12604
12605//AG:STXS2024
12606STXS12_tH::STXS12_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
12607: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12608{
12609 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12610 throw std::runtime_error("STXS12_tH called with a class whose parent is not NPbase");
12611
12612}
12613
12614double STXS12_tH::computeThValue() //AG:modified
12615{
12616 //-- Production:
12617 double weight = 1.0; //If normalized to the SM
12618 double muProd = myNPbase->STXS12_tH(sqrt_s);
12619 double muProd1 = muProd -1.0;
12620 double muProd2 = 0.0;
12621
12622 //-- Decay:
12623 double BrHXXRatio = 1.0;
12624 double dBrHXXRatio1 = 0.0;
12625 double dBrHXXRatio2 = 0.0;
12626 if (fstate==0){
12627 // Use for Cross-section [pb] with no Higgs-boson decay
12628 weight = 0.08207; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12629 } else if (fstate == 1){
12630 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12631 dBrHXXRatio1 = BrHXXRatio - 1.0;
12632 dBrHXXRatio2 = 0.0;
12633 } else if (fstate == 2){
12634 BrHXXRatio = (myNPbase->BrHgagaRatio());
12635 dBrHXXRatio1 = BrHXXRatio - 1.0;
12636 dBrHXXRatio2 = 0.0;
12637 } else if (fstate == 3){
12638 BrHXXRatio = (myNPbase->BrHbbRatio());
12639 dBrHXXRatio1 = BrHXXRatio - 1.0;
12640 dBrHXXRatio2 = 0.0;
12641 } else if (fstate == 4){
12642 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12643 dBrHXXRatio1 = BrHXXRatio - 1.0;
12644 dBrHXXRatio2 = 0.0;
12645 } else if (fstate == 5){
12646 BrHXXRatio = (myNPbase->BrHtautauRatio());
12647 dBrHXXRatio1 = BrHXXRatio - 1.0;
12648 dBrHXXRatio2 = 0.0;
12649 } else if (fstate == 6){
12650 BrHXXRatio = (myNPbase->BrHWWRatio());
12651 dBrHXXRatio1 = BrHXXRatio - 1.0;
12652 dBrHXXRatio2 = 0.0;
12653 } else if (fstate == 7){
12654 BrHXXRatio = (myNPbase->BrHZZRatio());
12655 dBrHXXRatio1 = BrHXXRatio - 1.0;
12656 dBrHXXRatio2 = 0.0;
12657 } else {
12658 throw std::runtime_error("STXS12_tH called with invalid argument for final state in fstate_i");
12659 }
12660
12661 //-- Production x Decay:
12662 if ((this->getModel()).isModelLinearized()){
12663 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12664 } else if((this->getModel()).isModelNPquadratic()){
12665 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12666 } else {
12667 return weight*(muProd)*(BrHXXRatio);
12668 }
12669
12670
12671}
12672
12673
12674
12675// -----------------------------------------------------------------------------
12676
12677
12678
12679//VM:STXS2025
12680STXS12_ttH_tH::STXS12_ttH_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
12681: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12682{
12683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12684 throw std::runtime_error("STXS12_ttH_tH called with a class whose parent is not NPbase");
12685
12686}
12687
12689{
12690 //-- Production:
12691 double weight = 1.0; //If normalized to the SM
12692 //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12693 //Since adding bins, include partial weigths (SM_predictions)
12694 double muProd = ( 0.09779*myNPbase->STXS12_ttH_pTH0_60(sqrt_s)
12700 + 0.08207*myNPbase->STXS12_tH(sqrt_s)
12701 ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 + 0.08207);
12702 double muProd1 = ( muProd - 1.0 );
12703 double muProd2 = 0.0;
12704
12705 //-- Decay:
12706 double BrHXXRatio = 1.0;
12707 double dBrHXXRatio1 = 0.0;
12708 double dBrHXXRatio2 = 0.0;
12709 if (fstate==0){
12710 weight = (0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 + 0.08207);
12711 } else if (fstate == 1){
12712 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12713 dBrHXXRatio1 = BrHXXRatio - 1.0;
12714 dBrHXXRatio2 = 0.0;
12715 } else if (fstate == 2){
12716 BrHXXRatio = (myNPbase->BrHgagaRatio());
12717 dBrHXXRatio1 = BrHXXRatio - 1.0;
12718 dBrHXXRatio2 = 0.0;
12719 } else if (fstate == 3){
12720 BrHXXRatio = (myNPbase->BrHbbRatio());
12721 dBrHXXRatio1 = BrHXXRatio - 1.0;
12722 dBrHXXRatio2 = 0.0;
12723 } else if (fstate == 4){
12724 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12725 dBrHXXRatio1 = BrHXXRatio - 1.0;
12726 dBrHXXRatio2 = 0.0;
12727 } else if (fstate == 5){
12728 BrHXXRatio = (myNPbase->BrHtautauRatio());
12729 dBrHXXRatio1 = BrHXXRatio - 1.0;
12730 dBrHXXRatio2 = 0.0;
12731 } else if (fstate == 6){
12732 BrHXXRatio = (myNPbase->BrHWWRatio());
12733 dBrHXXRatio1 = BrHXXRatio - 1.0;
12734 dBrHXXRatio2 = 0.0;
12735 } else if (fstate == 7){
12736 BrHXXRatio = (myNPbase->BrHZZRatio());
12737 dBrHXXRatio1 = BrHXXRatio - 1.0;
12738 dBrHXXRatio2 = 0.0;
12739 } else {
12740 throw std::runtime_error("STXS12_ttH called with invalid argument for final state in fstate_i");
12741 }
12742
12743 //-- Production x Decay:
12744 if ((this->getModel()).isModelLinearized()){
12745 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12746 } else if((this->getModel()).isModelNPquadratic()){
12747 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12748 } else {
12749 return weight*(muProd)*(BrHXXRatio);
12750 }
12751
12752}
12753
12754// -----------------------------------------------------------------------------
12755
12756
12757//-----------------------------------------------------------------------------------------
12758//-- Special Hadron collider signal strengths with separate full TH unc U(prod x decay) ---
12759//-----------------------------------------------------------------------------------------
12760
12761
12762muTHUggHgaga::muTHUggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
12763: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12764{
12765 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12766 throw std::runtime_error("muTHUggHgaga called with a class whose parent is not NPbase");
12767}
12768
12770{
12771 return myNPbase->muTHUggHgaga(sqrt_s);
12772}
12773
12774
12775muTHUVBFHgaga::muTHUVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
12776: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12777{
12778 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12779 throw std::runtime_error("muTHUVBFHgaga called with a class whose parent is not NPbase");
12780}
12781
12783{
12784 return myNPbase->muTHUVBFHgaga(sqrt_s);
12785}
12786
12787muTHUZHgaga::muTHUZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
12788: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12789{
12790 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12791 throw std::runtime_error("muTHUZHgaga called with a class whose parent is not NPbase");
12792}
12793
12795{
12796 return myNPbase->muTHUZHgaga(sqrt_s);
12797}
12798
12799muTHUWHgaga::muTHUWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
12800: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12801{
12802 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12803 throw std::runtime_error("muTHUWHgaga called with a class whose parent is not NPbase");
12804}
12805
12807{
12808 return myNPbase->muTHUWHgaga(sqrt_s);
12809}
12810
12811muTHUVHgaga::muTHUVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
12812: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12813{
12814 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12815 throw std::runtime_error("muTHUVHgaga called with a class whose parent is not NPbase");
12816}
12817
12819{
12820 return myNPbase->muTHUVHgaga(sqrt_s);
12821}
12822
12823muTHUttHgaga::muTHUttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
12824: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12825{
12826 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12827 throw std::runtime_error("muTHUttHgaga called with a class whose parent is not NPbase");
12828}
12829
12831{
12832 return myNPbase->muTHUttHgaga(sqrt_s);
12833}
12834
12835muTHUggHZga::muTHUggHZga(const StandardModel& SM_i, const double sqrt_s_i)
12836: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12837{
12838 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12839 throw std::runtime_error("muTHUggHZga called with a class whose parent is not NPbase");
12840}
12841
12843{
12844 return myNPbase->muTHUggHZga(sqrt_s);
12845}
12846
12847muTHUggHZgamumu::muTHUggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
12848: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12849{
12850 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12851 throw std::runtime_error("muTHUggHZgamumu called with a class whose parent is not NPbase");
12852}
12853
12855{
12856 return (myNPbase->muTHUggHZgamumu(sqrt_s));
12857}
12858
12859muTHUVBFHZga::muTHUVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
12860: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12861{
12862 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12863 throw std::runtime_error("muTHUVBFHZga called with a class whose parent is not NPbase");
12864}
12865
12867{
12868
12869 return myNPbase->muTHUVBFHZga(sqrt_s);
12870}
12871
12872muTHUZHZga::muTHUZHZga(const StandardModel& SM_i, const double sqrt_s_i)
12873: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12874{
12875 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12876 throw std::runtime_error("muTHUZHZga called with a class whose parent is not NPbase");
12877}
12878
12880{
12881 return myNPbase->muTHUZHZga(sqrt_s);
12882}
12883
12884muTHUWHZga::muTHUWHZga(const StandardModel& SM_i, const double sqrt_s_i)
12885: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12886{
12887 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12888 throw std::runtime_error("muTHUWHZga called with a class whose parent is not NPbase");
12889}
12890
12892{
12893 return myNPbase->muTHUWHZga(sqrt_s);
12894}
12895
12896muTHUVHZga::muTHUVHZga(const StandardModel& SM_i, const double sqrt_s_i)
12897: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12898{
12899 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12900 throw std::runtime_error("muTHUVHZga called with a class whose parent is not NPbase");
12901}
12902
12904{
12905 return myNPbase->muTHUVHZga(sqrt_s);
12906}
12907
12908muTHUttHZga::muTHUttHZga(const StandardModel& SM_i, const double sqrt_s_i)
12909: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12910{
12911 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12912 throw std::runtime_error("muTHUttHZga called with a class whose parent is not NPbase");
12913}
12914
12916{
12917 return myNPbase->muTHUttHZga(sqrt_s);
12918}
12919
12920muTHUggHZZ::muTHUggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
12921: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12922{
12923 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12924 throw std::runtime_error("muTHUggHZZ called with a class whose parent is not NPbase");
12925}
12926
12928{
12929 return myNPbase->muTHUggHZZ(sqrt_s);
12930}
12931
12932muTHUVBFHZZ::muTHUVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
12933: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12934{
12935 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12936 throw std::runtime_error("muTHUVBFHZZ called with a class whose parent is not NPbase");
12937}
12938
12940{
12941 return myNPbase->muTHUVBFHZZ(sqrt_s);
12942}
12943
12944muTHUZHZZ::muTHUZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
12945: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12946{
12947 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12948 throw std::runtime_error("muTHUZHZZ called with a class whose parent is not NPbase");
12949}
12950
12952{
12953 return myNPbase->muTHUZHZZ(sqrt_s);
12954}
12955
12956muTHUWHZZ::muTHUWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
12957: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12958{
12959 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12960 throw std::runtime_error("muTHUWHZZ called with a class whose parent is not NPbase");
12961}
12962
12964{
12965 return myNPbase->muTHUWHZZ(sqrt_s);
12966}
12967
12968muTHUVHZZ::muTHUVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
12969: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12970{
12971 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12972 throw std::runtime_error("muTHUVHZZ called with a class whose parent is not NPbase");
12973}
12974
12976{
12977 return myNPbase->muTHUVHZZ(sqrt_s);
12978}
12979
12980muTHUttHZZ::muTHUttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
12981: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12982{
12983 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12984 throw std::runtime_error("muTHUttHZZ called with a class whose parent is not NPbase");
12985}
12986
12988{
12989 return myNPbase->muTHUttHZZ(sqrt_s);
12990}
12991
12992muTHUggHZZ4l::muTHUggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
12993: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12994{
12995 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12996 throw std::runtime_error("muTHUggHZZ4l called with a class whose parent is not NPbase");
12997}
12998
13000{
13001 return myNPbase->muTHUggHZZ4l(sqrt_s);
13002}
13003
13004muTHUggHZZ4mu::muTHUggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
13005: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13006{
13007 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13008 throw std::runtime_error("muTHUggHZZ4mu called with a class whose parent is not NPbase");
13009}
13010
13012{
13013 return (myNPbase->muTHUggHZZ4mu(sqrt_s));
13014}
13015
13016muTHUVBFHZZ4l::muTHUVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
13017: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13018{
13019 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13020 throw std::runtime_error("muTHUVBFHZZ4l called with a class whose parent is not NPbase");
13021}
13022
13024{
13025 return myNPbase->muTHUVBFHZZ4l(sqrt_s);
13026}
13027
13028muTHUZHZZ4l::muTHUZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
13029: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13030{
13031 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13032 throw std::runtime_error("muTHUZHZZ4l called with a class whose parent is not NPbase");
13033}
13034
13036{
13037 return myNPbase->muTHUZHZZ4l(sqrt_s);
13038}
13039
13040muTHUWHZZ4l::muTHUWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
13041: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13042{
13043 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13044 throw std::runtime_error("muTHUWHZZ4l called with a class whose parent is not NPbase");
13045}
13046
13048{
13049 return myNPbase->muTHUWHZZ4l(sqrt_s);
13050}
13051
13052muTHUVHZZ4l::muTHUVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
13053: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13054{
13055 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13056 throw std::runtime_error("muTHUVHZZ4l called with a class whose parent is not NPbase");
13057}
13058
13060{
13061 return myNPbase->muTHUVHZZ4l(sqrt_s);
13062}
13063
13064muTHUttHZZ4l::muTHUttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
13065: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13066{
13067 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13068 throw std::runtime_error("muTHUttHZZ4l called with a class whose parent is not NPbase");
13069}
13070
13072{
13073 return myNPbase->muTHUttHZZ4l(sqrt_s);
13074}
13075
13076muTHUggHWW::muTHUggHWW(const StandardModel& SM_i, const double sqrt_s_i)
13077: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13078{
13079 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13080 throw std::runtime_error("muTHUggHWW called with a class whose parent is not NPbase");
13081}
13082
13084{
13085 return myNPbase->muTHUggHWW(sqrt_s);
13086}
13087
13088muTHUVBFHWW::muTHUVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
13089: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13090{
13091 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13092 throw std::runtime_error("muTHUVBFHWW called with a class whose parent is not NPbase");
13093}
13094
13096{
13097 return myNPbase->muTHUVBFHWW(sqrt_s);
13098}
13099
13100muTHUZHWW::muTHUZHWW(const StandardModel& SM_i, const double sqrt_s_i)
13101: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13102{
13103 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13104 throw std::runtime_error("muTHUZHWW called with a class whose parent is not NPbase");
13105}
13106
13108{
13109 return myNPbase->muTHUZHWW(sqrt_s);
13110}
13111
13112muTHUWHWW::muTHUWHWW(const StandardModel& SM_i, const double sqrt_s_i)
13113: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13114{
13115 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13116 throw std::runtime_error("muTHUWHWW called with a class whose parent is not NPbase");
13117}
13118
13120{
13121 return myNPbase->muTHUWHWW(sqrt_s);
13122}
13123
13124muTHUVHWW::muTHUVHWW(const StandardModel& SM_i, const double sqrt_s_i)
13125: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13126{
13127 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13128 throw std::runtime_error("muTHUVHWW called with a class whose parent is not NPbase");
13129}
13130
13132{
13133 return myNPbase->muTHUVHWW(sqrt_s);
13134}
13135
13136muTHUttHWW::muTHUttHWW(const StandardModel& SM_i, const double sqrt_s_i)
13137: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13138{
13139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13140 throw std::runtime_error("muTHUttHWW called with a class whose parent is not NPbase");
13141}
13142
13144{
13145 return myNPbase->muTHUttHWW(sqrt_s);
13146}
13147
13148muTHUggHWW2l2v::muTHUggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
13149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13150{
13151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13152 throw std::runtime_error("muTHUggHWW2l2v called with a class whose parent is not NPbase");
13153}
13154
13156{
13158}
13159
13160muTHUVBFHWW2l2v::muTHUVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
13161: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13162{
13163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13164 throw std::runtime_error("muTHUVBFHWW2l2v called with a class whose parent is not NPbase");
13165}
13166
13168{
13170}
13171
13172muTHUZHWW2l2v::muTHUZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
13173: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13174{
13175 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13176 throw std::runtime_error("muTHUZHWW2l2v called with a class whose parent is not NPbase");
13177}
13178
13180{
13181 return myNPbase->muTHUZHWW2l2v(sqrt_s);
13182}
13183
13184muTHUWHWW2l2v::muTHUWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
13185: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13186{
13187 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13188 throw std::runtime_error("muTHUWHWW2l2v called with a class whose parent is not NPbase");
13189}
13190
13192{
13193 return myNPbase->muTHUWHWW2l2v(sqrt_s);
13194}
13195
13196muTHUVHWW2l2v::muTHUVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
13197: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13198{
13199 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13200 throw std::runtime_error("muTHUVHWW2l2v called with a class whose parent is not NPbase");
13201}
13202
13204{
13205 return myNPbase->muTHUVHWW2l2v(sqrt_s);
13206}
13207
13208muTHUttHWW2l2v::muTHUttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
13209: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13210{
13211 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13212 throw std::runtime_error("muTHUttHWW2l2v called with a class whose parent is not NPbase");
13213}
13214
13216{
13218}
13219
13220muTHUggHmumu::muTHUggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
13221: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13222{
13223 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13224 throw std::runtime_error("muTHUggHmumu called with a class whose parent is not NPbase");
13225}
13226
13228{
13229 return myNPbase->muTHUggHmumu(sqrt_s);
13230}
13231
13232muTHUVBFHmumu::muTHUVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
13233: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13234{
13235 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13236 throw std::runtime_error("muTHUVBFHmumu called with a class whose parent is not NPbase");
13237}
13238
13240{
13241 return myNPbase->muTHUVBFHmumu(sqrt_s);
13242}
13243
13244muTHUZHmumu::muTHUZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
13245: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13246{
13247 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13248 throw std::runtime_error("muTHUZHmumu called with a class whose parent is not NPbase");
13249}
13250
13252{
13253 return myNPbase->muTHUZHmumu(sqrt_s);
13254}
13255
13256muTHUWHmumu::muTHUWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
13257: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13258{
13259 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13260 throw std::runtime_error("muTHUWHmumu called with a class whose parent is not NPbase");
13261}
13262
13264{
13265 return myNPbase->muTHUWHmumu(sqrt_s);
13266}
13267
13268muTHUVHmumu::muTHUVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
13269: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13270{
13271 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13272 throw std::runtime_error("muTHUVHmumu called with a class whose parent is not NPbase");
13273}
13274
13276{
13277 return myNPbase->muTHUVHmumu(sqrt_s);
13278}
13279
13280muTHUttHmumu::muTHUttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
13281: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13282{
13283 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13284 throw std::runtime_error("muTHUttHmumu called with a class whose parent is not NPbase");
13285}
13286
13288{
13289 return myNPbase->muTHUttHmumu(sqrt_s);
13290}
13291
13292muTHUggHtautau::muTHUggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
13293: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13294{
13295 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13296 throw std::runtime_error("muTHUggHtautau called with a class whose parent is not NPbase");
13297}
13298
13300{
13302}
13303
13304muTHUVBFHtautau::muTHUVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
13305: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13306{
13307 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13308 throw std::runtime_error("muTHUVBFHtautau called with a class whose parent is not NPbase");
13309}
13310
13312{
13314}
13315
13316muTHUZHtautau::muTHUZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
13317: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13318{
13319 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13320 throw std::runtime_error("muTHUZHtautau called with a class whose parent is not NPbase");
13321}
13322
13324{
13325 return myNPbase->muTHUZHtautau(sqrt_s);
13326}
13327
13328muTHUWHtautau::muTHUWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
13329: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13330{
13331 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13332 throw std::runtime_error("muTHUWHtautau called with a class whose parent is not NPbase");
13333}
13334
13336{
13337 return myNPbase->muTHUWHtautau(sqrt_s);
13338}
13339
13340muTHUVHtautau::muTHUVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
13341: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13342{
13343 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13344 throw std::runtime_error("muTHUVHtautau called with a class whose parent is not NPbase");
13345}
13346
13348{
13349 return myNPbase->muTHUVHtautau(sqrt_s);
13350}
13351
13352muTHUttHtautau::muTHUttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
13353: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13354{
13355 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13356 throw std::runtime_error("muTHUttHtautau called with a class whose parent is not NPbase");
13357}
13358
13360{
13362}
13363
13364muTHUggHbb::muTHUggHbb(const StandardModel& SM_i, const double sqrt_s_i)
13365: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13366{
13367 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13368 throw std::runtime_error("muTHUggHbb called with a class whose parent is not NPbase");
13369}
13370
13372{
13373 return myNPbase->muTHUggHbb(sqrt_s);
13374}
13375
13376muTHUVBFHbb::muTHUVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
13377: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13378{
13379 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13380 throw std::runtime_error("muTHUVBFHbb called with a class whose parent is not NPbase");
13381}
13382
13384{
13385 return myNPbase->muTHUVBFHbb(sqrt_s);
13386}
13387
13388muTHUZHbb::muTHUZHbb(const StandardModel& SM_i, const double sqrt_s_i)
13389: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13390{
13391 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13392 throw std::runtime_error("muTHUZHbb called with a class whose parent is not NPbase");
13393}
13394
13396{
13397 return myNPbase->muTHUZHbb(sqrt_s);
13398}
13399
13400muTHUWHbb::muTHUWHbb(const StandardModel& SM_i, const double sqrt_s_i)
13401: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13402{
13403 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13404 throw std::runtime_error("muTHUWHbb called with a class whose parent is not NPbase");
13405}
13406
13408{
13409 return myNPbase->muTHUWHbb(sqrt_s);
13410}
13411
13412muTHUVHbb::muTHUVHbb(const StandardModel& SM_i, const double sqrt_s_i)
13413: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13414{
13415 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13416 throw std::runtime_error("muTHUVHbb called with a class whose parent is not NPbase");
13417}
13418
13420{
13421 return myNPbase->muTHUVHbb(sqrt_s);
13422}
13423
13424muTHUttHbb::muTHUttHbb(const StandardModel& SM_i, const double sqrt_s_i)
13425: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13426{
13427 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13428 throw std::runtime_error("muTHUttHbb called with a class whose parent is not NPbase");
13429}
13430
13432{
13433 return myNPbase->muTHUttHbb(sqrt_s);
13434}
13435
13436
13437muTHUVBFBRinv::muTHUVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
13438: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13439{
13440 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13441 throw std::runtime_error("muTHUVBFBRinv called with a class whose parent is not NPbase");
13442}
13443
13445{
13446
13447 return (myNPbase->muTHUVBFBRinv(sqrt_s));
13448
13449}
13450
13451muTHUVBFHinv::muTHUVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
13452: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13453{
13454 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13455 throw std::runtime_error("muTHUVBFHinv called with a class whose parent is not NPbase");
13456}
13457
13459{
13460
13461 return (myNPbase->muTHUVBFHinv(sqrt_s));
13462
13463}
13464
13465
13466muTHUVHBRinv::muTHUVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
13467: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13468{
13469 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13470 throw std::runtime_error("muTHUVHBRinv called with a class whose parent is not NPbase");
13471}
13472
13474{
13475
13476 return (myNPbase->muTHUVHBRinv(sqrt_s));
13477
13478}
13479
13480muTHUVHinv::muTHUVHinv(const StandardModel& SM_i, const double sqrt_s_i)
13481: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13482{
13483 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13484 throw std::runtime_error("muTHUVHinv called with a class whose parent is not NPbase");
13485}
13486
13488{
13489 return (myNPbase->muTHUVHinv(sqrt_s));
13490}
double computeThValue()
A method to compute the branching ratio of Higgs decays into exotics (invisible or not).
BrHexotic(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHinvisible(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles.
const NPbase * myNPbase
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles (only decays into ne...
const NPbase * myNPbase
BrHinvisibleNP(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2e2muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
BrHto2e2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHto2l2v_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio Br Br in the current model and in the Standard Model.
BrHto2l2v_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2l2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto2mu2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHto4eRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4l_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br with in the current model and in the Standard Model.
BrHto4lRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto4muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoVVRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoZZRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoZga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaeeRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgallRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgamumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoZmumuga_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZmumuga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobb_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtobb_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoccRatio(const StandardModel &SM_i)
Constructor.
BrHtoevmuvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogaga_over_2e2mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_gg_Ratio(const StandardModel &SM_i)
Constructor.
BrHtogaga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtogg_over_bb_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogg_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoinvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtoll_vvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolljjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtolv_lvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolvjjRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtomumu_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtotautau_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtotautauRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtovisRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Higgs width in the current model and in the Standard Model.
GammaHRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoZZRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtoZgaRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtobbRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoccRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
GammaHtomumuRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtossRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtotautauRatio(const StandardModel &SM_i)
Constructor.
The auxiliary base model class for other model classes.
Definition: NPbase.h:66
virtual const double muggHbb(const double sqrt_s) const
Definition: NPbase.h:1872
virtual const double muVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1796
virtual const double STXS12_ggH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4075
virtual const double STXS_qqHll_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3680
virtual const double cbminuscc() const
Definition: NPbase.h:2869
virtual const double muTHUZHmumu(const double sqrt_s) const
Definition: NPbase.h:3055
virtual const double STXS12_qqHlv_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4348
virtual const double deltaGammaHtautauRatio1() const
Definition: NPbase.h:2053
virtual const double STXS12_qqHll_pTV0_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4438
virtual const double BrH4eRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2494
virtual const double mueeHvv(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1176
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3971
virtual const double muTHUttHWW(const double sqrt_s) const
Definition: NPbase.h:3019
virtual const double muTHUttHZga(const double sqrt_s) const
Definition: NPbase.h:2945
virtual const double BrH2evRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2602
virtual const double muTHUttHbb(const double sqrt_s) const
Definition: NPbase.h:3115
virtual const double STXS12_ggH_pTH450_650(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4086
virtual const double muggHZga(const double sqrt_s) const
Definition: NPbase.h:1659
virtual const double STXS_ggH_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3460
virtual const double cVpluscb() const
Definition: NPbase.h:2851
virtual const double deltaGammaHtautauRatio2() const
Definition: NPbase.h:2057
double C1HZZ
Definition: NPbase.h:5705
virtual const double STXS12_ggH_mjj0_350_pTH60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3980
virtual const double muVH(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1397
virtual const double muttHptH_HWW(const double sqrt_s) const
Definition: NPbase.h:1776
virtual const double mueeWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1151
virtual const double STXS12_ggHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4147
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4231
virtual const double STXS12_ggH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4065
virtual const double STXS_ggH1j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3506
virtual const double delta_mutH_2(const double sqrt_s) const
Definition: NPbase.h:1976
virtual const double muttH(const double sqrt_s) const
The ratio between the t-tbar-Higgs associated production cross-section in the current model and in t...
Definition: NPbase.h:1432
virtual const double muVBF(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in the current model and in...
Definition: NPbase.h:1127
virtual const double BrHZgaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2244
virtual const double STXS12_qqHqq_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4171
virtual const double mummZH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1537
virtual const double muepWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1226
virtual const double STXS_ggH2j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3555
virtual const double mummttH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1573
virtual const double GammaHccRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2162
virtual const double muttHgagaZeeboost(const double sqrt_s) const
The ratio in the , channel channel in the current model and in the Standard Model.
Definition: NPbase.h:1596
virtual const double muttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1743
virtual const double muVHZga(const double sqrt_s) const
Definition: NPbase.h:1675
virtual const double muggHpbbH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1844
virtual const double muTHUZHZZ(const double sqrt_s) const
Definition: NPbase.h:2957
virtual const double STXS_qqHll_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3709
virtual const double muZHmumu(const double sqrt_s) const
Definition: NPbase.h:1812
virtual const double STXS12_qqHlv_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4330
virtual const double STXS12_BrHbbRatio() const
The STXS BR .
Definition: NPbase.h:3857
virtual const double ccminusctau() const
Definition: NPbase.h:2887
virtual const double muTHUttHZZ(const double sqrt_s) const
Definition: NPbase.h:2969
virtual const double STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4216
virtual const double STXS_qqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3585
virtual const double muVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:1808
virtual const double STXS12_ttH_pTH0_60(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4465
virtual const double muggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1723
virtual const double delta_muZH_2(const double sqrt_s) const
Definition: NPbase.h:1949
virtual const double cgaplusct() const
Definition: NPbase.h:2833
virtual const double muTHUVBFBRinv(const double sqrt_s) const
Definition: NPbase.h:3120
virtual const double muTHUVBFHZga(const double sqrt_s) const
Definition: NPbase.h:2929
virtual const double deltaGammaHbbRatio2() const
Definition: NPbase.h:2039
virtual const double muWHpT250(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1260
virtual const double muttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1800
virtual const double STXS_ggH1j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3497
virtual const double STXS12_qqHll_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4447
virtual const double BrHVVRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2234
virtual const double muggHpttH(const double sqrt_s) const
The ratio between the sum of gluon-gluon fusion and t-tbar-Higgs associated production cross-section...
Definition: NPbase.h:1477
virtual const double STXS12_qqHqq_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4180
virtual const double muTHUVHBRinv(const double sqrt_s) const
Definition: NPbase.h:3130
virtual const double delta_mutH_1(const double sqrt_s) const
Definition: NPbase.h:1972
virtual const double delta2sBRH3(const double C1prod, const double C1Hxx) const
Quadratic contribution from the Higgs self-couplings modifications to the signal strength for in the...
Definition: NPbase.h:2752
virtual const double muTHUZHgaga(const double sqrt_s) const
Definition: NPbase.h:2909
virtual const double muTHUggHZZ(const double sqrt_s) const
Definition: NPbase.h:2949
virtual const double muTHUVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:2953
virtual const double STXS12_ggH_pTH200_300_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3866
virtual const double STXS12_ggHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4129
virtual const double muggHpttHptHpbbH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1832
virtual const double GammaHbbRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2182
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4240
virtual const double STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4276
virtual const double muTHUggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3023
virtual const double STXS_ggH2j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3535
virtual const double STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4303
virtual const double muVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:1699
virtual const double muTHUggHWW(const double sqrt_s) const
Definition: NPbase.h:2999
virtual const double cgplusct() const
Definition: NPbase.h:2824
virtual const double muttHtautau(const double sqrt_s) const
Definition: NPbase.h:1864
virtual const double STXS_ZHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3820
virtual const double muTHUggHZga(const double sqrt_s) const
Definition: NPbase.h:2925
virtual const double mueettH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1489
virtual const double muTHUZHbb(const double sqrt_s) const
Definition: NPbase.h:3103
virtual const double STXS12_ggH_pTH650_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4098
virtual const double muVBFHWW(const double sqrt_s) const
Definition: NPbase.h:1756
virtual const double muWHWW(const double sqrt_s) const
Definition: NPbase.h:1764
virtual const double STXS12_qqHlv_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4384
virtual const double muVBFHZga(const double sqrt_s) const
Definition: NPbase.h:1663
virtual const double muVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1784
virtual const double deltaGammaTotalRatio1() const
Definition: NPbase.h:2071
virtual const double mueeZHGen(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1295
virtual const double STXS12_ggH_pTH60_120_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3953
virtual const double STXS12_BrH4lRatio() const
The STXS BR , .
Definition: NPbase.h:3833
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4267
virtual const double STXS_ZHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3793
virtual const double BrH2e2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2395
virtual const double BrH2e2muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2359
virtual const double BrHbbRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2337
virtual const double muggHgaga(const double sqrt_s) const
Definition: NPbase.h:1601
virtual const double muVHcc(const double sqrt_s) const
Definition: NPbase.h:1904
virtual const double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1346
virtual const double STXS12_ggH_pTH650_Inf_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3893
virtual const double muttHptH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1619
virtual const double STXS_qqHll_pTV_150_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3689
virtual const double BrHZgallRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2254
virtual const double deltaGammaHZgaRatio2() const
Definition: NPbase.h:2030
virtual const double STXS12_ggH_pTH300_450_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3875
virtual const double deltaGammaHmumuRatio1() const
Definition: NPbase.h:2044
virtual const double STXS12_qqHlv_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4339
virtual const double STXS12_qqHlv_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4375
virtual const double STXS_WHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3748
virtual const double STXS_qqHll_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3699
virtual const double muTHUWHbb(const double sqrt_s) const
Definition: NPbase.h:3107
virtual const double STXS_ttHtH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3729
virtual const double muTHUVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2990
virtual const double muppHmumu(const double sqrt_s) const
Definition: NPbase.h:1908
virtual const double muTHUVHinv(const double sqrt_s) const
Definition: NPbase.h:3135
virtual const double BrHll_vvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2681
virtual const double delta_muttH_2(const double sqrt_s) const
Definition: NPbase.h:1967
virtual const double muZHZga(const double sqrt_s) const
Definition: NPbase.h:1667
virtual const double deltaGammaHmumuRatio2() const
Definition: NPbase.h:2048
virtual const double STXS_ggH1j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3479
virtual const double C1eeZBF(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1780
virtual const double muZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1788
virtual const double muttHWW(const double sqrt_s) const
Definition: NPbase.h:1772
virtual const double muVHZZ(const double sqrt_s) const
Definition: NPbase.h:1711
virtual const double STXS12_ttH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4492
virtual const double deltaGammaHZgaRatio1() const
Definition: NPbase.h:2026
double C1Htautau
Definition: NPbase.h:5704
virtual const double deltaGammaHWWRatio1() const
Definition: NPbase.h:1999
virtual const double muTHUVHgaga(const double sqrt_s) const
Definition: NPbase.h:2917
virtual const double STXS_qqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3575
virtual const double muggHpbbH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1695
double C1Hbb
Definition: NPbase.h:5704
virtual const double GammaHggRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2089
virtual const double delta_muggH_1(const double sqrt_s) const
Definition: NPbase.h:1918
virtual const double STXS_qqHll_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3719
virtual const double muZH(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1271
virtual const double delta_muVBF_1(const double sqrt_s) const
Definition: NPbase.h:1927
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4016
virtual const double deltaGammaHZZRatio1() const
Definition: NPbase.h:2008
virtual const double muTHUVHWW(const double sqrt_s) const
Definition: NPbase.h:3015
virtual const double STXS_ZHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3784
virtual const double GammaHZZRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2109
double C1Hgg
Definition: NPbase.h:5705
virtual const double BrHZZRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2224
virtual const double STXS_qqHqq_nonVHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3594
virtual const double muWHZga(const double sqrt_s) const
Definition: NPbase.h:1671
virtual const double muTHUttHtautau(const double sqrt_s) const
Definition: NPbase.h:3091
virtual const double muVBFpVH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1836
virtual const double muttHptH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1719
virtual const double muTHUVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3039
virtual const double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1502
virtual const double C1eeWBF(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1680
virtual const double mueeZH(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1309
virtual const double STXS12_ggH_pTH450_650_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3884
virtual const double GammaHWWRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2099
virtual const double BrHtoinvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2731
virtual const double muTHUttHgaga(const double sqrt_s) const
Definition: NPbase.h:2921
virtual const double BrH2muvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2611
virtual const double STXS_ggH_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3450
virtual const double muggHmumu(const double sqrt_s) const
Definition: NPbase.h:1804
virtual const double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1189
virtual const double muggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1780
virtual const double muttHptH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1868
virtual const double muZHbb(const double sqrt_s) const
Definition: NPbase.h:1884
double C1Hcc
Definition: NPbase.h:5704
virtual const double deltaGammaTotalRatio2() const
Definition: NPbase.h:2075
virtual const double STXS12_ggHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4120
virtual const double STXS_qqHlv_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3671
virtual const double muWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1792
virtual const double STXS12_ggHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4111
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4043
virtual const double STXS_WHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3766
virtual const double STXS_ZHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3802
virtual const double muZHtautau(const double sqrt_s) const
Definition: NPbase.h:1852
virtual const double muTHUVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:2905
virtual const double deltaGammaHgagaRatio2() const
Definition: NPbase.h:2021
virtual const double muTHUWHWW(const double sqrt_s) const
Definition: NPbase.h:3011
virtual const double deltaGammaHgagaRatio1() const
Definition: NPbase.h:2017
virtual const double mutHgaga(const double sqrt_s) const
Definition: NPbase.h:1607
virtual const double muTHUWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3035
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4007
virtual const double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1359
virtual const double STXS12_ggH_pTH10_200_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3921
virtual const double BrHssRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2327
virtual const double delta_muttH_1(const double sqrt_s) const
Definition: NPbase.h:1963
virtual const double muZHgaga(const double sqrt_s) const
Definition: NPbase.h:1643
virtual const double UpperLimitZgammaC(const double sqrt_s) const
Definition: NPbase.h:2815
virtual const double C1eettH(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1830
virtual const double BrH4lRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2632
virtual const double STXS_qqHqq_VHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3603
virtual const double muWHgaga(const double sqrt_s) const
Definition: NPbase.h:1647
virtual const double STXS12_BrHevmuvRatio() const
The STXS BR .
Definition: NPbase.h:3841
virtual const double STXS_qqHlv_pTV_0_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3631
virtual const double Br_H_inv() const
The branching ratio of the of the Higgs into invisible particles.
Definition: NPbase.h:2701
virtual const double STXS12_ttH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4510
virtual const double BrHggRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2204
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4025
virtual const double muVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1727
virtual const double mummH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1513
virtual const double mummHNWA(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model,...
Definition: NPbase.h:1525
virtual const double STXS_ggH2j_pTH_0_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3515
virtual const double STXS12_ggH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4054
virtual const double BrHgagaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2284
virtual const double muVBFHbb(const double sqrt_s) const
Definition: NPbase.h:1880
virtual const double STXS12_qqHqq_mjj0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4189
virtual const double mueeZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1201
virtual const double STXS_ggH1j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3488
virtual const double UpperLimitZgammaA13(const double sqrt_s) const
Definition: NPbase.h:2788
virtual const double muTHUVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:3051
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3998
virtual const double STXS12_qqHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4393
virtual const double muTHUggHZZ4mu(const double sqrt_s) const
Definition: NPbase.h:3140
virtual const double computeGammaTotalRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2192
virtual const double STXS12_ggH_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4034
virtual const double delta2sH3(const double C1) const
Quadratic contribution from the Higgs self-couplings modifications to the signal strength for an obse...
Definition: NPbase.h:2743
virtual const double muTHUWHtautau(const double sqrt_s) const
Definition: NPbase.h:3083
virtual const double muTHUVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2978
virtual const double muZHWW(const double sqrt_s) const
Definition: NPbase.h:1760
virtual const double STXS12_qqHqq_mjj60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4198
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4249
double C1Hgaga
Definition: NPbase.h:5705
virtual const double C1eeZH(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1630
virtual const double cbminusctau() const
Definition: NPbase.h:2878
virtual const double BrHlvjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2663
virtual const double muVBFpVH(const double sqrt_s) const
The ratio between the sum of VBF and WH+ZH associated production cross-section in the current model ...
Definition: NPbase.h:1421
virtual const double GammaHssRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2172
double C1Hss
Definition: NPbase.h:5704
virtual const double BrH2mu2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2404
virtual const double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1164
virtual const double muTHUttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2994
virtual const double muWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1735
virtual const double UpperLimitZgammaC13(const double sqrt_s) const
Definition: NPbase.h:2797
virtual const double muTHUttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3043
virtual const double STXS12_ggHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4138
virtual const double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1214
virtual const double STXS12_ggH_mjj0_350_pTH120_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3989
virtual const double GammaHZgaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2119
virtual const double GammaHgagaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2129
virtual const double Br_H_exo() const
The branching ratio of the of the Higgs into exotic particles.
Definition: NPbase.h:2692
virtual const double muggHpbbH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1613
virtual const double muWHbb(const double sqrt_s) const
Definition: NPbase.h:1888
virtual const double muVHWW(const double sqrt_s) const
Definition: NPbase.h:1768
virtual const double muTHUVHZZ(const double sqrt_s) const
Definition: NPbase.h:2965
virtual const double muggHH(const double sqrt_s) const
The ratio between the gluon-gluon fusion di-Higgs production cross-section in the current model and ...
Definition: NPbase.h:1116
virtual const double STXS_ggH2j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3545
virtual const double muttHZbbboost(const double sqrt_s) const
The ratio in the channel in the current model and in the Standard Model.
Definition: NPbase.h:1585
virtual const double STXS_qqHqq_VBFtopo_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3565
virtual const double muTHUWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2986
virtual const double STXS_WHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3757
virtual const double deltaGammaHZZRatio2() const
Definition: NPbase.h:2012
virtual const double muWHtautau(const double sqrt_s) const
Definition: NPbase.h:1856
virtual const double muTHUggHtautau(const double sqrt_s) const
Definition: NPbase.h:3071
virtual const double GammaHmumuRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2142
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3932
virtual const double STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4285
double C1HZga
The C1 coefficient controlling the H^3 corrections to the Higgs partial width from the Higgs trilinea...
Definition: NPbase.h:5705
virtual const double BrHZgaeeRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2264
virtual const double STXS_WHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3775
virtual const double BrHevmuvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2548
virtual const double muTHUVBFHinv(const double sqrt_s) const
Definition: NPbase.h:3125
virtual const double muggHpVBFpbbH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1876
virtual const double GammaHtautauRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2152
virtual const double muTHUggHgaga(const double sqrt_s) const
Definition: NPbase.h:2900
virtual const double muVHbb(const double sqrt_s) const
Definition: NPbase.h:1892
virtual const double STXS12_qqHll_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4456
virtual const double muTHUggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2974
virtual const double muttHgaga(const double sqrt_s) const
Definition: NPbase.h:1655
virtual const double muTHUggHbb(const double sqrt_s) const
Definition: NPbase.h:3095
virtual const double muTHUWHgaga(const double sqrt_s) const
Definition: NPbase.h:2913
virtual const double muWHmumu(const double sqrt_s) const
Definition: NPbase.h:1816
virtual const double muZHZZ(const double sqrt_s) const
Definition: NPbase.h:1703
virtual const double muttHZZ(const double sqrt_s) const
Definition: NPbase.h:1715
virtual const double deltaGammaHbbRatio1() const
Definition: NPbase.h:2035
virtual const double muWH(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1249
virtual const double STXS12_tH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:4528
virtual const double C1eeHvv(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1730
double C1HWW
Definition: NPbase.h:5705
virtual const double muWHZZ(const double sqrt_s) const
Definition: NPbase.h:1707
virtual const double Br_H_inv_NP() const
The branching ratio of the of the Higgs into invisible particles (only invisible new particles).
Definition: NPbase.h:2711
virtual const double muggHtautau(const double sqrt_s) const
Definition: NPbase.h:1840
virtual const double muttHmumu(const double sqrt_s) const
Definition: NPbase.h:1824
virtual const double STXS12_ggH_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3944
virtual const double muggHZZ(const double sqrt_s) const
Definition: NPbase.h:1691
virtual const double BrHlljjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2654
virtual const double muTHUVBFHWW(const double sqrt_s) const
Definition: NPbase.h:3003
virtual const double STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4312
virtual const double muVBFpVH_HZga(const double sqrt_s) const
Definition: NPbase.h:1687
virtual const double STXS_qqHlv_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3651
virtual const double STXS12_qqHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4411
virtual const double BrHvisRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2721
double C1Hmumu
The C1 coefficient controlling the H^3 corrections to the Higgs partial width from the Higgs trilinea...
Definition: NPbase.h:5704
virtual const double STXS12_BrHgagaRatio() const
The STXS BR .
Definition: NPbase.h:3849
virtual const double BrHccRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2317
virtual const double muVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:1848
virtual const double muTHUVHbb(const double sqrt_s) const
Definition: NPbase.h:3111
virtual const double bPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1385
virtual const double muVHpT250(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1409
virtual const double delta_muVBF_2(const double sqrt_s) const
Definition: NPbase.h:1931
virtual const double STXS_ggH0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3470
virtual const double STXS12_qqHqq_VH_veto_Nj01(const double sqrt_s) const
The STXS bin , VH-veto Ref. 2402.05742.
Definition: NPbase.h:4158
virtual const double STXS12_qqHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4420
virtual const double mutHq(const double sqrt_s) const
The ratio between the t-q-Higgs associated production cross-section in the current model and in the ...
Definition: NPbase.h:1465
virtual const double muTHUggHZgamumu(const double sqrt_s) const
Definition: NPbase.h:3145
virtual const double STXS_ggH2j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3525
virtual const double STXS12_ggH_pTH10_Inf_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3911
virtual const double mummHvv(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1549
virtual const double STXS12_qqHlv_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4321
virtual const double muVHtautau(const double sqrt_s) const
Definition: NPbase.h:1860
virtual const double muggHpttHptHpbbH_HZga(const double sqrt_s) const
Definition: NPbase.h:1683
virtual const double BrH2l2vRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2641
virtual const double BrH4muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2503
virtual const double muttHZga(const double sqrt_s) const
Definition: NPbase.h:1679
virtual const double muTHUZHtautau(const double sqrt_s) const
Definition: NPbase.h:3079
virtual const double BrHmumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2297
virtual const double muVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:1639
virtual const double STXS12_qqHqq_mjj120_350_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4207
virtual const double STXS12_ggH_pTH120_200_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3962
virtual const double UpperLimitZgammaA(const double sqrt_s) const
Definition: NPbase.h:2806
virtual const double muTHUZHZga(const double sqrt_s) const
Definition: NPbase.h:2933
virtual const double BrHWWRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2214
virtual const double muTHUVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3027
virtual const double BrHZgamumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2274
virtual const double mueeZllH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1321
virtual const double delta_muZH_1(const double sqrt_s) const
Definition: NPbase.h:1945
virtual const double muVHmumu(const double sqrt_s) const
Definition: NPbase.h:1820
virtual const double STXS_WHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3739
virtual const double muTHUVHmumu(const double sqrt_s) const
Definition: NPbase.h:3063
virtual const double cgminuscga() const
Definition: NPbase.h:2842
virtual const double STXS0_qqH(const double sqrt_s) const
The STXS0 bin .
Definition: NPbase.h:3438
virtual const double delta_muggH_2(const double sqrt_s) const
Definition: NPbase.h:1922
virtual const double muTHUWHZZ(const double sqrt_s) const
Definition: NPbase.h:2961
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4258
virtual const double muTHUVHtautau(const double sqrt_s) const
Definition: NPbase.h:3087
virtual const double muZHpT250(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1282
virtual const double muppHZga(const double sqrt_s) const
Definition: NPbase.h:1912
virtual const double STXS_qqHqq_pTj_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3622
virtual const double STXS_qqHlv_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3641
virtual const double muVBFgamma(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in association with a hard ...
Definition: NPbase.h:1139
virtual const double muggHgagaInt(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
Definition: NPbase.h:1634
virtual const double BrHlv_lvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2672
virtual const double muggH(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section in the current model and in ...
Definition: NPbase.h:1105
virtual const double deltaGammaHWWRatio2() const
Definition: NPbase.h:2003
virtual const double STXS12_ttH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4519
virtual const double muggHWW(const double sqrt_s) const
Definition: NPbase.h:1748
virtual const double cVplusctau() const
Definition: NPbase.h:2860
virtual const double muTHUZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3031
virtual const double STXS_ZHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3811
virtual const double muepZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1238
virtual const double delta_muWH_1(const double sqrt_s) const
Definition: NPbase.h:1936
virtual const double muTHUVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:3075
virtual const double muggHpbbH_HWW(const double sqrt_s) const
Definition: NPbase.h:1752
virtual const double STXS12_qqHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4402
virtual const double delta_muWH_2(const double sqrt_s) const
Definition: NPbase.h:1940
virtual const double muttHbb(const double sqrt_s) const
Definition: NPbase.h:1896
virtual const double muVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1739
virtual const double muTHUWHZga(const double sqrt_s) const
Definition: NPbase.h:2937
virtual const double mutH(const double sqrt_s) const
The ratio between the t-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1443
virtual const double STXS12_ttH_pTH60_120(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4474
virtual const double aPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1372
virtual const double muTHUVBFHbb(const double sqrt_s) const
Definition: NPbase.h:3099
virtual const double muTHUWHmumu(const double sqrt_s) const
Definition: NPbase.h:3059
virtual const double STXS12_qqHlv_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4357
virtual const double mueeZqqH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1333
virtual const double STXS_qqHlv_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3661
virtual const double muTHUZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2982
virtual const double STXS12_qqHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4429
virtual const double muttHptH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1828
virtual const double muVHgaga(const double sqrt_s) const
Definition: NPbase.h:1651
virtual const double muttHptH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1900
virtual const double muTHUttHmumu(const double sqrt_s) const
Definition: NPbase.h:3067
virtual const double STXS12_ttH_pTH120_200(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4483
virtual const double STXS_qqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3613
virtual const double BrHtautauRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2307
virtual const double muTHUggHmumu(const double sqrt_s) const
Definition: NPbase.h:3047
virtual const double muZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1731
virtual const double STXS12_ggH_pTH0_10_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3902
virtual const double muTHUZHWW(const double sqrt_s) const
Definition: NPbase.h:3007
virtual const double mummHmm(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1561
virtual const double STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4294
virtual const double muTHUVHZga(const double sqrt_s) const
Definition: NPbase.h:2941
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
unsigned int fstate
STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_10_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_Inf_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH120_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_450_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH450_650_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_650(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH60_120_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH60_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
unsigned int fstate
STXS12_qqHll(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
STXS12_qqHqq_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
STXS12_qqHqq_VH_veto_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj120_350_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
const double sqrt_s
unsigned int fstate
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH0_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH0_60(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH120_200(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf_add(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH60_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
unsigned int fstate
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
STXS_0_qqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSWHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
STXSggH0j4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH2j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VBFtopo_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_nonVHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_pTj_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSttHtH4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
A model class for the Standard Model.
A class for a model prediction of an observable.
Definition: ThObservable.h:25
const StandardModel & getModel()
A get method to get the model.
Definition: ThObservable.h:100
const StandardModel & SM
A reference to an object of StandardMode class.
Definition: ThObservable.h:121
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
UpperLimit_ppHZgammaC13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaC(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
VBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of .
VBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
VBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
VBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
WHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
WHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
ZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
aPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
bPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
cV_plus_cb(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
cV_plus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cb_minus_cc(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
const NPbase * myNPbase
cb_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cc_minus_ctau(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
const NPbase * myNPbase
cg_minus_cga(const StandardModel &SM_i)
Constructor.
cg_plus_ct(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cga_plus_ct(const StandardModel &SM_i)
Constructor.
ggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
ggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
ggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
ggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
muTHUVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muTHUVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muTHUVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
muTHUWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muTHUWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muTHUZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
muTHUZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVBFgamma(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVBFpVH_HZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muVBFpVH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muVBFpVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
muVBFpVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const NPbase * myNPbase
muVHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
muVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muWH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
muWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
double computeThValue()
const NPbase * myNPbase
muZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muZHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mueeHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mueeHvvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeHvvZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double Pol_em
mueeHvvccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeHvvgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
mueeHvvggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
mueeHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeHvvss(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvssPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeWBFWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mueeWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeWBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueeWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeZBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
mueeZBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHBRinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHGen(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const double Pol_em
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
mueeZH(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHWW(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeZHZZ(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
mueeZHZga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeZHbb(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHcc(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHgaga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
mueeZHgg(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
mueeZHinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHmumu(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHss(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
mueeZHtautau(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZllH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeZllHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
mueeZqqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZqqHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueettH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueettHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueettHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
mueettHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepWBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepWBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muepWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
muepWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muepWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muepZBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muepZBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepZBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepZBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muggHH2ga2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muggH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
muggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
muggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muggHgagaInt(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
muggHpVBFpbbH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muggHpbbH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muggHpbbH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muggHpbbH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHpbbH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muggHpttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHpttHptHpbbH_HZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpttHptHpbbH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHWWNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHZgaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbbNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHccNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
mummHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHgagaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHggNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHmm(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHmmWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHmmZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
mummHmmZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHmmgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mummHmmgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummHmmtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmumuNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHtautauNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mummHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
mummZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
mummZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mummttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummttHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muppHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muppHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
double computeThValue()
const double sqrt_s
mutHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mutHq(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muttHVV(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZbbboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHgagaZeeboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the channel in the current model.
const NPbase * myNPbase
muttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHptH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muttHptH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHptH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muttHptH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muttHptH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
ttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
ttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase